Threadly - SwiftGit

SwiftUI

Threadly

March 15, 2024

Threadly is a Swift µframework that allows for type-safe thread-local storage.

What is Thread-Local Storage?

Thread-local storage (TLS) lets you define a single variable that each thread has its own separate copy of. This is great for cases such as having a mutable global variable that can’t be safely accessed by multiple threads.

One example of this is with random number generators. Each thread can have its own seeded generator that’s mutated on a per-thread basis. While this may potentially use more memory, it’s much faster than accessing a shared global variable through a mutex.

Build Status

Installation

Compatibility

Platforms:
- macOS 10.9+
- iOS 8.0+
- watchOS 2.0+
- tvOS 9.0+
- Linux
Xcode 8.0+
Swift 3.0+

Install Using Swift Package Manager

The Swift Package Manager is a decentralized dependency manager for Swift.

Add the project to your Package.swift.


                                              
                                                import PackageDescription
let package = Package(

name: “MyAwesomeProject”,

dependencies: [

.Package(url: “https://github.com/nvzqz/Threadly.git”,

majorVersion: 1)

]

)

Import the Threadly module.


                                              
                                                import Threadly

Install Using CocoaPods

CocoaPods is a centralized dependency manager for Objective-C and Swift. Go here to learn more.

Add the project to your Podfile.


                                              
                                                use_frameworks!
pod ‘Threadly’, ‘~> 2.0.1’

If you want to be on the bleeding edge, replace the last line with:


                                              
                                                pod ‘Threadly’, :git => ‘https://github.com/nvzqz/Threadly.git’

Run pod install and open the .xcworkspace file to launch Xcode.
Import the Threadly framework.


                                              
                                                import Threadly

Install Using Carthage

Carthage is a decentralized dependency manager for Objective-C and Swift.

Add the project to your Cartfile.


                                              
                                                github “nvzqz/Threadly”

Run carthage update and follow the additional steps in order to add Threadly to your project.
Import the Threadly framework.


                                              
                                                import Threadly

Install Manually

Simply add Threadly.swift into your project.

Usage

Try it out for yourself! Download the repo and open ‘Threadly.playground’.

Initialization

There are two ways to initialize a thread-local value. The value can be initialized lazily when retrieved (init(value:) & init(create:)) or at the call site (init(capturing:)).

Using init(value:) is an @autoclosure shorthand for init(create:). This means that the thread-local value is initialized once per thread.


                                              
                                                import Foundation
let array = ThreadLocal(value: [1, 2, 3])
Thread.detachNewThread {

// Allocates an array with 3 elements for this thread

let arr = array.inner.value

doStuff(with: arr)

}
// Allocates another array of 3 elements for the main thread

doStuff(with: array.inner.value)

When using init(capturing:), the thread-local value is initialized at the call site.


                                              
                                                import Foundation
// The inner value gets allocated

let array = ThreadLocal(capturing: [1, 2, 3])
Thread.detachNewThread {

// Retrieves a shallow copy of the initial value that can be used in this

// thread. If the thread-local value gets mutated, a deep copy occurs to

// retain value semantics.

let arr = array.inner.value

doStuff(with: arr)

}
// Same as the other thread, but now in the main thread

doStuff(with: array.inner.value)

Exclusivity

Each thread has exclusive access to its own local variable.


                                              
                                                import Foundation
let num = ThreadLocal(value: 42)
Thread.detachNewThread {

withUnsafePointer(to: &num.inner.value) { ptr in

print(ptr) // 0x00007fa6f86074a0

}

}
withUnsafePointer(to: &num.inner.value) { ptr in

print(ptr) // 0x00007fa6f844c920

}

GitHub

View Github

#carthage #cocoapods #concurrency #ios #linux #macos #swift #thread #tvos #type-safety