Synchronisation dans une application Web Go-lang

Question

J'écris une application web golang. L'application Web accède au système de fichiers (lecture et écriture) et à un fichier de base de données sqlite3.

Question 1: Comment puis-je synchroniser l'accès au système de fichiers dans Go?

type DataObject struct { 
    data []byte 
} 

func (*d DataObject) Write() { 
    // 
    // Synchronization ? 
    // 
    ioutil.WriteFile("file.name", d.data, 0644) 
    // 
    // Stop synchronization ? 
    // 
} 

---

Question 2: Ai-je besoin de synchroniser l'accès aux fichiers de base de données sqlite3?

type SqlObject struct { 
    sqldata string 
} 

func (*s SqlObject) Store() error { 
    // 
    // Open the file, do I need some sort of synchronization? 
    // 
    con, err := sqlite.Open("database/datafile.db") 
    if err != nil { 
    return err 
    } 
    defer con.Close() 

    err = con.Exec("INSERT INTO data(sqldata) values(?)", s.sqldata) 
    if err != nil { 
    return err 
    } 
    return nil 
} 

J'utilise le pilote gosqlite3 (http://code.google.com/p/gosqlite/).

Answer 1

Pour les fichiers, cela dépend de votre application. Si vous avez seulement un goroutine qui écrit dans le fichier, vous ne devriez pas avoir besoin de le faire. Si plus d'un alors il dépend:

Si vous coordonnez entre différents processus (programmes) vous pouvez utiliser flock (et ce ne sera probablement pas amusant).

Si vous coordonnez plusieurs goroutines dans votre programme, vous pouvez utiliser mutexes ou vous pouvez voir si vous pouvez réorganiser le programme afin qu'une seule routine écrit dans le fichier et que les autres envoient des mises à jour via les canaux. Pour SQLite, je crois que le plus simple serait de garder une connexion sqlite ouverte et d'utiliser celle des goroutines; bien qu'il supporte plusieurs processus l'ayant ouvert en même temps et si votre système effectue plusieurs lectures simultanées qui pourraient être plus rapides (il utilise un verrou global pour l'écriture).

Answer 2

Question 1

Le package fournit "sync" Lock et rwlock pour synchroniser l'accès aux ressources de façon classique. Bien qu'il n'y ait rien de mal à cela, j'aime jouer avec les idiomes afin que je puisse faire quelque chose comme this:

package main 

import "fmt" 

func SyncFile(path string) chan<- func(string) { 
    ch := make(chan func(string)) 
    go func() { 
     for process := range ch { 
      process(path) 
     } 
    }() 
    return ch 
} 

func main() { 
    data := SyncFile("data.name") 
    data <- func(path string) { 
     fmt.Println(path) 
    } 
} 

Alors si vous accédez uniquement le fichier par ce canal de funcs, l'accès sera synchronisé. C'est fiable, mais vous pourrez peut-être trouver quelque chose de plus efficace.

Question 2

Le pilote gosqlite3 est juste un Go obligatoire à libsqlite3, de sorte que le SQLite FAQ applique (et il semble que vous êtes en clair à ce sujet). Si vous souhaitez que ces deux éléments soient synchronisés entre eux, il vous suffit d'envelopper l'utilisation de SQLite dans le code de synchronisation d'accès au fichier.

Answer 3

1) Vous devez utiliser un mutex en lecture/écriture (dans la bibliothèque go std). code ressemblerait à quelque chose comme:

import "sync" // http://golang.org/pkg/sync/ 
const (
    filename = "file.name" 
) 
var globalFileLock sync.RWMutex 

type DataObject struct { 
    data []byte 
} 

func (*d DataObject) Write() { 
    globalFileLock.Lock() 
    defer globalFileLock.Unlock() 
    ioutil.WriteFile(filename, d.data, 0644) 
} 

func (*d DataObject) Read() { 
    globalFileLock.RLock() 
    defer globalFileLock.RUnlock() 
    d.data = ioutil.ReadFile(filename) 
} 

2) Comme vous l'avez pas posté la section « importation » de votre programme, je ne sais pas quel pilote SQLite que vous utilisez.

Si vous utilisez la base de données/sql pour ouvrir la connexion à la base de données, le pilote fournit un contrôle de simultanéité entre les goroutines.

Answer 4

Je sais que une vieille question, mais depuis que j'ai eu le même problème « de verrouillage db », et une transaction résolu pour moi, je pensais que je mentionne ici:

db, err := sql.Open("sqlite3", db_path) 
if err != nil { 
    log.Printf("Cannot connect to database: %s\n", err) 
} 
defer db.Close() 
tx, _ := db.Begin() 
var value string 
err = tx.QueryRow("SELECT X FROM Y").Scan(&value) 
tx.Rollback() // or: tx.Commit()