https://github.com/satrobit/go-pthreads
POSIX Threads (pthreads) bindings in Go
https://github.com/satrobit/go-pthreads
go golang pthread thread
Last synced: about 1 month ago
JSON representation
POSIX Threads (pthreads) bindings in Go
- Host: GitHub
- URL: https://github.com/satrobit/go-pthreads
- Owner: satrobit
- License: bsd-2-clause
- Created: 2020-07-08T20:33:49.000Z (over 5 years ago)
- Default Branch: master
- Last Pushed: 2020-07-08T20:54:16.000Z (over 5 years ago)
- Last Synced: 2024-06-20T11:51:12.898Z (over 1 year ago)
- Topics: go, golang, pthread, thread
- Language: Go
- Homepage:
- Size: 9.77 KB
- Stars: 2
- Watchers: 2
- Forks: 1
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
README
go-pthreads
===========
This is a binding of C's pthreads to Google Go. **This library is not a
replacement for goroutines.** This library is designed to help bind C libraries
with blocking function calls to Go in a go-friendly manner. If this is not your
use case, this library probably won't help you.
This is a fork of [liamzdenek/go-pthreads](https://github.com/liamzdenek/go-pthreads).
I will be making substantial changes to this repository over the next few months so interface isn't stable and no version will be released until a stable interface achieved.
Use Case
--------
If a goroutine exists that calls a function that will block potentially
indefinitely, that goroutine cannot be stopped until the blocking function
returns and the goroutine checks an "exit" channel, and exits of its own will.
In every day go programming, this condition should not exist, as all inter-
thread communication, as well as reading and writing, should be done using
channels. However, in C, many libraries (and, in my specific case, networking
libraries) implement blocking functions (recv), and the mixture of a blocking
function and a multi-channel select caused many implementation problems and
"hacks" to get the "blocking" function to return periodically, so the exit
channel could be checked, and the routine could exit if it had to.
Example
-------
```go
package main;
import (
"github.com/liamzdenek/go-pthreads"
"fmt"
)
func main() {
thread := pthread.Create(func() {
// we're within the pthread
counter := 1;
for {
// time to make a blocking function call. The library includes
// pthread.sleep for demo purposes, but this will work with any
// library that causes IO wait
// an example using github.com/alecthomas/gozmq can be found in
// Thread_test.go
fmt.Printf("Hello, %d\n", counter)
counter++
pthread.Sleep(1) // seconds
}
})
// within the main goroutine
pthread.Sleep(3)
fmt.Printf("Killing thread\n");
thread.Kill()
pthread.Sleep(3);
}
```
Output:
```
$ time go run test.go
Hello, 1
Hello, 2
Hello, 3
Killing thread
go run test.go 0.28s user 0.09s system 5% cpu 6.421 total
```
Pros/Cons
---------
Pros:
* Provides a mechanism to kill a blocked thread (thread.Kill())
* Provides thread status without any logic in the child (thread.Running())
Cons:
* Does not implement pthread_cleanup_push/pop
* Runs in a dedicated thread (most of the time; sometimes this is a pro)
* Does not integrate with the go scheduler (as a consequence of the new thread)
* Harder to debug (crashes in C code don't produce stack traces)
Credits
---------
This repository is based on [liamzdenek/go-pthreads](https://github.com/liamzdenek/go-pthreads)