GetMutex

https://pub.dev/packages/get_mutex
Admin
GetMutex is a robust, efficient, and deadlock-free synchronization library for Dart providing...
Tokens:4,015
Snippets:60
Trust Score:9.9
Update:4 months ago
Show doc for...
Tokens:
Raw
### Mutex Protection Example

Source: https://pub.dev/packages/get_mutex/example

Demonstrates nested mutex protection to ensure sequential execution of asynchronous tasks. This example verifies that tasks within the mutex are executed in the expected order.

```dart
void main(){
    final mutex = Mutex();
    final executionOrder = <int>[];
      await mutex.protect(() async {
        executionOrder.add(1);
            await mutex.protect(() async {
            executionOrder.add(2);
            await mutex.protect(() async {
                executionOrder.add(3);
            });
            executionOrder.add(4);
            });
            executionOrder.add(5);
        });
        executionOrder.add(6);

        if(executionOrder.toString() == [1, 2, 3, 4, 5, 6].toString()) {
            print('All good!');
        } else {
            throw Exception('Fail :('); // This will never happen
        }
      }

```

--------------------------------

### Add get_mutex Dependency to pubspec.yaml

Source: https://pub.dev/packages/get_mutex/install

This is an example of how the get_mutex dependency will appear in your pubspec.yaml file after running the add command.

```yaml
dependencies:
  get_mutex: ^1.0.0
```

--------------------------------

### Dart Bank Account Transfer Using Await

Source: https://pub.dev/packages/get_mutex/versions/1.0.0

This example shows how to use sequential 'await' calls to manage bank account transfers, preventing race conditions but potentially impacting performance. It measures the elapsed time for these sequential operations.

```dart
void main() async {
  final accountA = BankAccount('Account A', 1000);
  final accountB = BankAccount('Account B', 500);

  final clockWatch = Stopwatch()..start();
  await accountA.transfer(accountB, 200);
  await accountA.transfer(accountB, 300);
  await accountB.transfer(accountA, 100);
  await accountB.transfer(accountA, 700);
  clockWatch.stop();
  print('Elapsed time using await: ${clockWatch.elapsedMilliseconds} ms');
  // Output: Elapsed time using await: 209 ms
}

```

--------------------------------

### BankAccount Transfer with Mutex

Source: https://pub.dev/packages/get_mutex/versions/1.0.0

Demonstrates safe concurrent transfers between bank accounts using the Mutex class to protect shared balance data. This example shows how to prevent race conditions during simultaneous operations.

```dart
import 'package:get_mutex/get_mutex.dart';

class BankAccount {
  final String accountNumber;
  double balance;
  final mutex = Mutex();

  BankAccount(this.accountNumber, this.balance);

  Future<bool> transfer(BankAccount targetAccount, double amount) async {
    return await mutex.protectWrite(() async {
      if (amount > balance) return false;
      balance -= amount;
      await targetAccount.deposit(amount);
      return true;
    });
  }

  Future<void> deposit(double amount) async => balance += amount;
}

void main() async {
  final accountA = BankAccount('Account A', 1000);
  final accountB = BankAccount('Account B', 500);

  final transfers = [
    accountA.transfer(accountB, 200),
    accountA.transfer(accountB, 300),
    accountB.transfer(accountA, 100),
    accountB.transfer(accountA, 700),
  ];

  final clockWatch = Stopwatch()..start();
  await Future.wait(transfers);
  clockWatch.stop();
  print('Elapsed time using mutex: ${clockWatch.elapsedMilliseconds} ms');
  // Output: Elapsed time using mutex: 107 ms

  print('Final Balances:');
  print('${accountA.accountNumber}: \$${accountA.balance}'); // Account A: $1300.0
  print('${accountB.accountNumber}: \$${accountB.balance}'); // Account B: $200.0
}

```

--------------------------------

### Import get_mutex in Dart Code

Source: https://pub.dev/packages/get_mutex/install

Import the get_mutex package into your Dart files to start using its synchronization features.

```dart
import 'package:get_mutex/get_mutex.dart';
```

--------------------------------

### Dart Bank Account Transfer Without Synchronization

Source: https://pub.dev/packages/get_mutex/versions/1.0.0

This example demonstrates a race condition scenario in Dart bank account transfers without proper synchronization. It simulates concurrent transfers that can lead to incorrect final balances due to overlapping operations.

```dart
import 'dart:async';

class BankAccount {
  final String accountNumber;
  double balance;

  BankAccount(this.accountNumber, this.balance);

  Future<bool> transfer(BankAccount targetAccount, double amount) async {
    if (amount > balance) {
      return false; // Insufficient funds
    }

    await Future.delayed(Duration(milliseconds: 50)); // Simulating processing time

    balance -= amount;

    await Future.delayed(Duration(milliseconds: 50)); // Simulate some delay

    targetAccount.balance += amount;

    return true;
  }
}

void main() async {
  final accountA = BankAccount('Account A', 1000);
  final accountB = BankAccount('Account B', 500);

  // Simulate multiple concurrent transfers
  final transfers = [
    accountA.transfer(accountB, 200), // Account A: $800, Account B: $700
    accountA.transfer(accountB, 300), // Account A: $500, Account B: $1000
    accountB.transfer(accountA, 100), // Account A: $600, Account B: $900
    accountB.transfer(accountA, 700), // Account A: $1300, Account B: $200
  ];

  final results = await Future.wait(transfers);

  print('Transfer Results:');
  for (var result in results) {
    print(result ? 'Transfer succeeded' : 'Transfer failed');
  }
  // Possible Output:
  // Transfer succeeded
  // Transfer succeeded
  // Transfer succeeded
  // Transfer failed

  print('Final Balances:');
  print('${accountA.accountNumber}: \$${accountA.balance}');
  print('${accountB.accountNumber}: \$${accountB.balance}');
  // Possible Output:
  // Account A: $600.0
  // Account B: $900.0
}

```

--------------------------------

### SimpleMutex and SimpleReentrantMutex Usage

Source: https://pub.dev/packages/get_mutex/versions/1.0.0

Demonstrates the usage of SimpleMutex for basic locking and SimpleReentrantMutex for allowing nested locks within the same thread.

```dart
final simpleMutex = SimpleMutex();
await simpleMutex.protect(() => print('Simple Mutex'));


```

```dart
final simpleReentrantMutex = SimpleReentrantMutex();
await simpleReentrantMutex.protect(() {
  print('Simple Reentrant Mutex');
  simpleReentrantMutex.protect(() => print('Reentrant Mutex inside'));
});

```

--------------------------------

### SimpleMutex Usage

Source: https://pub.dev/packages/get_mutex

Shows how to use the SimpleMutex for basic mutual exclusion, ensuring that only one operation can execute the protected code block at a time. This is a straightforward implementation for simple locking needs.

```dart
final simpleMutex = SimpleMutex();
await simpleMutex.protect(() => print('Simple Mutex'));

```

--------------------------------

### Basic Mutex Usage

Source: https://pub.dev/packages/get_mutex/versions/1.0.0

Illustrates the fundamental usage of the Mutex class for protecting a critical section of code. Ensures that only one operation can access the protected resource at a time.

```dart
import 'package:get_mutex/get_mutex.dart';

final mutex = Mutex();
await mutex.protectWrite(() {
  // Your critical section here
  print('Writing safely!');
});

```

--------------------------------

### MIT License

Source: https://pub.dev/packages/get_mutex/license

The MIT License grants broad permissions for using, copying, modifying, merging, publishing, distributing, and sublicensing the software. It requires the inclusion of the copyright notice and permission notice in all copies or substantial portions of the Software. The software is provided 'as is' without warranty.

```plaintext
MIT License

Copyright (c) 2024 Jonny Borges

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
```

--------------------------------

### SimpleReentrantMutex Usage

Source: https://pub.dev/packages/get_mutex

Demonstrates the SimpleReentrantMutex, which allows the same thread to acquire the lock multiple times. This is useful for recursive functions or nested critical sections within the same execution context.

```dart
final simpleReentrantMutex = SimpleReentrantMutex();
await simpleReentrantMutex.protect(() {
  print('Simple Reentrant Mutex');
  simpleReentrantMutex.protect(() => print('Reentrant Mutex inside'));
});

```

--------------------------------

### Add GetMutex to pubspec.yaml

Source: https://pub.dev/packages/get_mutex/versions/1.0.0

Specifies how to include the GetMutex package as a dependency in your Dart project's pubspec.yaml file.

```yaml
dependencies:
  get_mutex: ^1.0.0

```

--------------------------------

### Advanced Mutex Features

Source: https://pub.dev/packages/get_mutex/versions/1.0.0

Demonstrates advanced features of the Mutex class, including read-write locks, timeouts, and cancellation tokens for more granular control over concurrent operations.

```dart
final mutex = Mutex();

// Optimize for multiple readers
await mutex.protectRead(() => print('Reading in parallel'));

// Ensure exclusive access for writers
await mutex.protectWrite(() => print('Writing exclusively'));

// Set a timeout to avoid deadlocks
await mutex.protectWrite(() => longOperation(), timeout: Duration(seconds: 5));

// Use cancellation for more control
final token = CancellationToken();
await mutex.protectWrite(() => cancelableOperation(), cancellationToken: token);

```

--------------------------------

### RawReadWriteMutex Usage

Source: https://pub.dev/packages/get_mutex/versions/1.0.0

Shows how to use the RawReadWriteMutex for fine-grained control over read and write access to shared resources. Note that this mutex does not support reentrant locks.

```dart
final rwMutex = RawReadWriteMutex();

await rwMutex.protectRead(() => print('Reading in parallel'));
await rwMutex.protectWrite(() => print('Writing exclusively'));


Future<T> myCustomProtectWrite<T>(
    Future<T> Function() action, {
    CancellationToken? cancellationToken,
    Duration? timeout,
  }) {
    await rwMutex.acquireWrite(cancellationToken: cancellationToken, timeout: timeout);
    try {
      return await action();
    } finally {
      rwMutex.releaseWrite();
    }
}

```

--------------------------------

### Add get_mutex to Flutter Project

Source: https://pub.dev/packages/get_mutex/install

Use this command to add the get_mutex package as a dependency in your Flutter project.

```bash
$ flutter pub add get_mutex
```

--------------------------------

### Add get_mutex to Dart Project

Source: https://pub.dev/packages/get_mutex/install

Use this command to add the get_mutex package as a dependency in your Dart project.

```bash
$ dart pub add get_mutex
```

--------------------------------

### GetMutex Alias Usage

Source: https://pub.dev/packages/get_mutex/versions/1.0.0

Illustrates how to use the GetMutex alias class to access different mutex implementations (Mutex, RawReadWriteMutex, SimpleMutex, SimpleReentrantMutex) through a unified interface.

```dart
final mutex = GetMutex.mutex();
await mutex.protectWrite(() => print('Writing safely!'));

final rwMutex = GetMutex.rawReadWriteMutex();
await rwMutex.protectRead(() => print('Reading in parallel'));

final simpleMutex = GetMutex.simpleMutex();
await simpleMutex.protect(() => print('Simple Mutex'));

final simpleReentrantMutex = GetMutex.simpleReentrantMutex();
await simpleReentrantMutex.protect(() {
  print('Simple Reentrant Mutex');
  simpleReentrantMutex.protect(() => print('Reentrant Mutex inside'));
});

```

--------------------------------

### Default Clause Warning in Read Write Mutex

Source: https://pub.dev/packages/get_mutex/score

A warning indicating a default clause is covered by previous cases in the read_write_mutex.dart file. This analysis was performed using lints_core.

```dart
      default:

```
Tokens:
Raw