Skip to main content
SimilarExport ZIP
100%

find a thread safety bug

✓ Published0🌍 Public
RRestuta
Last edited Feb 8, 2012
Created on Feb 8, 2012

This example demonstrates a subtle thread-safety bug in a C# .NET console application. Two `ThreadUnsafe` instances execute a `Go()` method concurrently across 10,000 iterations, with a shared static `_val2` flag reset after each attempt. The code uses the `lock` keyword on a `syncObj` to guard the division `_val1/_val2`, but the assignment `_val2 = 0` occurs outside the lock. The visualization—rendered via console output—shows the iteration index and an `AggregateException` when a race condition triggers an arithmetic error, revealing the unprotected write that breaks the intended synchronization.

AI-generated description

Similar vizzes

Loading thumbnail…

Shared via Rust Playground

This example demonstrates how multiple threads can safely share and mutate a counter using Rust’s concurrency primitives. It shows the `Arc<Mutex<Toaster>>` pattern, where an atomic mutex lock protects the `count` field from race conditions. The code spawns three threads via `thread::spawn`, each cloning the `Arc` handle and acquiring the lock with `toaster.lock().unwrap()` before incrementing the count. The output prints each thread’s index, which is assigned from the prior value of `count` before incrementing. The example uses the standard library’s `std::sync::{Arc, Mutex}` and `std::thread` APIs, with no external data source or rendering—purely console output.

FFranklin Chen
58% match
Loading thumbnail…

C++ abuse: simple example

This example demonstrates the dangerous consequences of low-level memory manipulation in C++, where swapping an object’s vtable pointer with another object’s changes its runtime behavior. The code uses raw `void*` casts and pointer arithmetic in the `transmigrate` and `brain_damage` functions to overwrite the virtual function table entries of a `Dog` object with those of a `Cat`, causing the program to call the wrong virtual methods. The output sequence—showing `Dog::food()` initially, then `Cat::food()` after the swap, and finally undefined behavior after the vtable corruption—illustrates how such manual pointer juggling bypasses type safety and virtual dispatch. The example relies solely on standard C++ features like virtual functions, inheritance, and explicit pointer casts, with no external libraries.

FFranklin Chen
51% match
Loading thumbnail…

Gist 740340

This example demonstrates a parallelized aggregate operation that sums the integers from zero to one million using Language-Integrated Query (LINQ). The code uses the `Enumerable.Range` method to generate the data sequence and calls `AsParallel()` to enable parallel execution across multiple threads. The `Aggregate` function then combines each element with an accumulator, applying the addition lambda `(x, y) => x + y` to produce the total. The visualization likely maps the resulting sum or the execution process, though the rendering method is not specified in the provided source code.

RRestuta
49% match
Loading thumbnail…

Gist 5ef57ecbfb116e6b42706fb6a30b0987

This example demonstrates a common JavaScript scoping pitfall with the `var` keyword, contrasting it with `let`. It shows that declaring multiple variables in a single statement like `var i, r = 0;` only initializes the last variable (`r`), leaving `i` as `undefined`. Consequently, while loops testing `i < 10` never execute, while loops on `r` run ten times, printing "chau". The visualization, presented as a code gist, uses plain JavaScript console output via `console.log` within `while` loops, relying on the browser's or Node.js runtime rather than any external libraries. The gist highlights the importance of explicit initialization for each variable.

MMistyBlunch
48% match
Loading thumbnail…

chuhai async

This example demonstrates how asynchronous timing errors in benchmark code can skew results, contrasting a correct benchmark with a buggy variant. The visualization, generated by the `chuhai` and `blue-tape` libraries, compares operations per second for `nextTick`, `setTimeout`, and `setImmediate`, alongside a synchronous `max` baseline. In the buggy version, shared variable mutations inside asynchronous callbacks produce incorrect factorial calculations, as shown by failed assertions. The rendered bar chart highlights performance differences, with `nextTick` fastest when correct, while the buggy results falsely elevate `setImmediate` due to the timing mistakes.

HHypercubed
48% match
Loading thumbnail…

Shared via Rust Playground

This example simulates a concurrent breakfast scenario using Rust's standard library. It shows how multiple attendee threads send bagels through channels to a single toaster thread, which toasts them and returns them via acknowledgment channels. The visualization highlights thread synchronization and message passing with `std::thread::spawn`, `std::sync::mpsc::channel`, and channel send/receive operations. The code prints toasting progress and final consumption messages, illustrating the choreography of concurrent tasks through inter-thread communication. No external libraries or data sources are used; the rendering is purely textual output from the console.

FFranklin Chen
47% match
Loading thumbnail…

Gist 10288187

This example demonstrates the importance of bounds checking in C++ vector access. It uses the `std::vector` class and its `.at()` method, which throws an exception when the given index is out of range, in contrast to the unchecked `[]` operator. A loop iterates from zero to four over a vector containing three integers, triggering an out-of-range error that is caught by an `exception` handler. The code also shows a custom destructor message when a `Foo` object, managed via `make_shared`, is cleaned up.

FFranklin Chen
46% match
Loading thumbnail…

Gist 5001434

This example shows a debugging scenario for event sourcing, where two events with identical timestamps are replayed and returned in unpredictable order. The code displays two event objects—`UserCreatedEvent` and `UserCredentialsCreatedEvent`—with their UUIDs and aggregate root IDs, using JavaScript object literals. It illustrates the problem of sorting by `DateTime.Utc.Now` when fast-sequenced commands produce equal dates, leading to logical ordering failures. The example renders the raw event data and aggregates as plain text, relying on standard JavaScript syntax rather than any visualization library, focusing on the conceptual issue of timestamp collisions in EventStore queries.

RRestuta
46% match