ペコペコ ded
forum
abraker's list of locked thread. 5w4z6s
posted
Total Posts
1,418
Thank god...Zelzatter Zero wrote: 4b5m27
community/forums/topics/1105007
oof
nah. Ephermeral is okay, he doesn't spam vtuber shit on every fucking occasion.Lights wrote: 4un10
nono, we're going to sacrifice Meah to cure ephemeral of his v-tuber syndrome. Will be a thread shortlyKatouMegumi wrote: 4d5u5e
guys can we exile meah for a week or something? they need to calm down and reflect on their actions
That's fast.Hydreigon wrote: 5z4u4o
community/forums/topics/1108938
2 in 1 day
i have been defeated TwTZelzatter Zero wrote: 4b5m27
community/forums/topics/1109407
I think any GMT can do it.Zelzatter Zero wrote: 4b5m27
community/forums/topics/1108741
poor Death... he have to edit the post again
ABRAKER! I WAS TYPING AT THE MOMENT IT WAS LOCKED.
WHA- ;-;.
Source: "I give you a random number between 0 and 999" by Corne2Plum3, click here.
WHA- ;-;.
Source: "I give you a random number between 0 and 999" by Corne2Plum3, click here.
You seems lucky thenJustABeginner wrote: 5l405f
ABRAKER! I WAS TYPING AT THE MOMENT IT WAS LOCKED.
WHA- ;-;.
Source: "I give you a random number between 0 and 999" by Corne2Plum3, click here.
GMT can edit other people's post but it would then be written aseblf2013 wrote: 331669
I think any GMT can do it.Zelzatter Zero wrote: 4b5m27
community/forums/topics/1108741
poor Death... he have to edit the post again
last edited by abraker
but here it is written
last edited by death
so it really is death who edits this post, unless GMT can also hide their edit.
OMG ABRAKER LOCKED MY THREAD!!! ILY ABBY-KUN!!!!axl2468 wrote: 521952
community/forums/topics/1112772
abraker strikes again
the title should be "the zoo's closed"axl2468 wrote: 521952
community/forums/topics/1112772
abraker strikes again
niceHydreigon wrote: 5z4u4o
community/forums/topics/1094775
the church died again, at exactly 200 posts, nice
That was quickZelzatter Zero wrote: 4b5m27
community/forums/topics/1113434
yo
i mean, thats one way to write code nobody will want to stealDeath wrote: 4c6b
I personally prefer i -=- 1
Its not a very good idea.Winnyace wrote: 182q6t
used that countless times. papa bless the guy who came out with the idea of -=-
i -= (value) is just shorthand for i = i - (value)
and the value being subtracted is -1
so you're just doing: i = i - (-1)
which is just i = i + 1
which is just a longer way of accomplishing ++i
Death you are a top tier code troll.
++.byname("Lights").socialStats[.byname("Death").id].respect;
let’s see here…Zelzatter Zero wrote: 4b5m27
community/forums/topics/1069793
care to explain why abrakaer?
dumb gameplay-related thread
posted in the wrong section
question that has been asked a million times
necro’ed
yeah wtf abraker come on man get a grip
cArE tO ExPlAin?Serraionga wrote: 2r3s1z
let’s see here…Zelzatter Zero wrote: 4b5m27
community/forums/topics/1069793
care to explain why abrakaer?
dumb gameplay-related thread
posted in the wrong section
question that has been asked a million times
necro’ed
yeah wtf abraker come on man get a grip
community/forums/topics/1114310
In computer science, a lock or mutex (from mutual exclusion) is a synchronization mechanism for enforcing limits on access to a resource in an environment where there are many threads of execution. A lock is designed to enforce a mutual exclusion concurrency control policy.
Contents
1 Types
2 Granularity
3 Database locks
4 Disadvantages
4.1 Lack of composability
5 Language
6 See also
7 References
8 External links
Types
Generally, locks are advisory locks, where each thread cooperates by acquiring the lock before accessing the corresponding data. Some systems also implement mandatory locks, where attempting unauthorized access to a locked resource will force an exception in the entity attempting to make the access.
The simplest type of lock is a binary semaphore. It provides exclusive access to the locked data. Other schemes also provide shared access for reading data. Other widely implemented access modes are exclusive, intend-to-exclude and intend-to-upgrade.
Another way to classify locks is by what happens when the lock strategy prevents progress of a thread. Most locking designs block the execution of the thread requesting the lock until it is allowed to access the locked resource. With a spinlock, the thread simply waits ("spins") until the lock becomes available. This is efficient if threads are blocked for a short time, because it avoids the overhead of operating system process re-scheduling. It is inefficient if the lock is held for a long time, or if the progress of the thread that is holding the lock depends on preemption of the locked thread.
Locks typically require hardware for efficient implementation. This usually takes the form of one or more atomic instructions such as "test-and-set", "fetch-and-add" or "compare-and-swap". These instructions allow a single process to test if the lock is free, and if free, acquire the lock in a single atomic operation.
Uniprocessor architectures have the option of using uninterruptable sequences of instructions—using special instructions or instruction prefixes to disable interrupts temporarily—but this technique does not work for multiprocessor shared-memory machines. Proper for locks in a multiprocessor environment can require quite complex hardware or software , with substantial synchronization issues.
The reason an atomic operation is required is because of concurrency, where more than one task executes the same logic. For example, consider the following C code:
if (lock == 0) {
// lock free, set it
lock = myPID;
}
The above example does not guarantee that the task has the lock, since more than one task can be testing the lock at the same time. Since both tasks will detect that the lock is free, both tasks will attempt to set the lock, not knowing that the other task is also setting the lock. Dekker's or Peterson's algorithm are possible substitutes if atomic locking operations are not available.
Careless use of locks can result in deadlock or livelock. A number of strategies can be used to avoid or recover from deadlocks or livelocks, both at design-time and at run-time. (The most common strategy is to standardize the lock acquisition sequences so that combinations of inter-dependent locks are always acquired in a specifically defined "cascade" order.)
Some languages do locks syntactically. An example in C# follows:
public class // This is a monitor of an
{
private decimal _balance = 0;
private object _balanceLock = new object();
public void Deposit(decimal amount)
{
// Only one thread at a time may execute this statement.
lock (_balanceLock)
{
_balance += amount;
}
}
public void Withdraw(decimal amount)
{
// Only one thread at a time may execute this statement.
lock (_balanceLock)
{
_balance -= amount;
}
}
}
The code lock(this) can lead to problems if the instance can be accessed publicly.[1]
Similar to Java, C# can also synchronize entire methods, by using the MethodImplOptions.Synchronized attribute.[2][3]
[MethodImpl(MethodImplOptions.Synchronized)]
public void SomeMethod()
{
// do stuff
}
Granularity
Before being introduced to lock granularity, one needs to understand three concepts about locks:
lock overhead: the extra resources for using locks, like the memory space allocated for locks, the U time to initialize and destroy locks, and the time for acquiring or releasing locks. The more locks a program uses, the more overhead associated with the usage;
lock contention: this occurs whenever one process or thread attempts to acquire a lock held by another process or thread. The more fine-grained the available locks, the less likely one process/thread will request a lock held by the other. (For example, locking a row rather than the entire table, or locking a cell rather than the entire row.);
deadlock: the situation when each of at least two tasks is waiting for a lock that the other task holds. Unless something is done, the two tasks will wait forever.
There is a tradeoff between decreasing lock overhead and decreasing lock contention when choosing the number of locks in synchronization.
An important property of a lock is its granularity. The granularity is a measure of the amount of data the lock is protecting. In general, choosing a coarse granularity (a small number of locks, each protecting a large segment of data) results in less lock overhead when a single process is accessing the protected data, but worse performance when multiple processes are running concurrently. This is because of increased lock contention. The more coarse the lock, the higher the likelihood that the lock will stop an unrelated process from proceeding. Conversely, using a fine granularity (a larger number of locks, each protecting a fairly small amount of data) increases the overhead of the locks themselves but reduces lock contention. Granular locking where each process must hold multiple locks from a common set of locks can create subtle lock dependencies. This subtlety can increase the chance that a programmer will unknowingly introduce a deadlock.[citation needed]
In a database management system, for example, a lock could protect, in order of decreasing granularity, part of a field, a field, a record, a data page, or an entire table. Coarse granularity, such as using table locks, tends to give the best performance for a single , whereas fine granularity, such as record locks, tends to give the best performance for multiple s.
Database locks
Main article: Lock (database)
Database locks can be used as a means of ensuring transaction synchronicity. i.e. when making transaction processing concurrent (interleaving transactions), using 2-phased locks ensures that the concurrent execution of the transaction turns out equivalent to some serial ordering of the transaction. However, deadlocks become an unfortunate side-effect of locking in databases. Deadlocks are either prevented by pre-determining the locking order between transactions or are detected using waits-for graphs. An alternate to locking for database synchronicity while avoiding deadlocks involves the use of totally ordered global timestamps.
There are mechanisms employed to manage the actions of multiple concurrent s on a database—the purpose is to prevent lost updates and dirty reads. The two types of locking are pessimistic locking and optimistic locking:
Pessimistic locking: a who reads a record with the intention of updating it places an exclusive lock on the record to prevent other s from manipulating it. This means no one else can manipulate that record until the releases the lock. The downside is that s can be locked out for a very long time, thereby slowing the overall system response and causing frustration.
Where to use pessimistic locking: this is mainly used in environments where data-contention (the degree of s request to the database system at any one time) is heavy; where the cost of protecting data through locks is less than the cost of rolling back transactions, if concurrency conflicts occur. Pessimistic concurrency is best implemented when lock times will be short, as in programmatic processing of records. Pessimistic concurrency requires a persistent connection to the database and is not a scalable option when s are interacting with data, because records might be locked for relatively large periods of time. It is not appropriate for use in Web application development.
Optimistic locking: this allows multiple concurrent s access to the database whilst the system keeps a copy of the initial-read made by each . When a wants to update a record, the application determines whether another has changed the record since it was last read. The application does this by comparing the initial-read held in memory to the database record to any changes made to the record. Any discrepancies between the initial-read and the database record violates concurrency rules and hence causes the system to disregard any update request. An error message is generated and the is asked to start the update process again. It improves database performance by reducing the amount of locking required, thereby reducing the load on the database server. It works efficiently with tables that require limited updates since no s are locked out. However, some updates may fail. The downside is constant update failures due to high volumes of update requests from multiple concurrent s - it can be frustrating for s.
Where to use optimistic locking: this is appropriate in environments where there is low contention for data, or where read-only access to data is required. Optimistic concurrency is used extensively in .NET to address the needs of mobile and disconnected applications,[4] where locking data rows for prolonged periods of time would be infeasible. Also, maintaining record locks requires a persistent connection to the database server, which is not possible in disconnected applications.
Disadvantages
Lock-based resource protection and thread/process synchronization have many disadvantages:
Contention: some threads/processes have to wait until a lock (or a whole set of locks) is released. If one of the threads holding a lock dies, stalls, blocks, or enters an infinite loop, other threads waiting for the lock may wait forever.
Overhead: the use of locks adds overhead for each access to a resource, even when the chances for collision are very rare. (However, any chance for such collisions is a race condition.)
Debugging: bugs associated with locks are time dependent and can be very subtle and extremely hard to replicate, such as deadlocks.
Instability: the optimal balance between lock overhead and lock contention can be unique to the problem domain (application) and sensitive to design, implementation, and even low-level system architectural changes. These balances may change over the life cycle of an application and may entail tremendous changes to update (re-balance).
Composability: locks are only composable (e.g., managing multiple concurrent locks in order to atomically delete item X from table A and insert X into table B) with relatively elaborate (overhead) software and perfect adherence by applications programming to rigorous conventions.
Priority inversion: a low-priority thread/process holding a common lock can prevent high-priority threads/processes from proceeding. Priority inheritance can be used to reduce priority-inversion duration. The priority ceiling protocol can be used on uniprocessor systems to minimize the worst-case priority-inversion duration, as well as prevent deadlock.
Convoying: all other threads have to wait if a thread holding a lock is descheduled due to a time-slice interrupt or page fault.
Some concurrency control strategies avoid some or all of these problems. For example, a funnel or serializing tokens can avoid the biggest problem: deadlocks. Alternatives to locking include non-blocking synchronization methods, like lock-free programming techniques and transactional memory. However, such alternative methods often require that the actual lock mechanisms be implemented at a more fundamental level of the operating software. Therefore, they may only relieve the application level from the details of implementing locks, with the problems listed above still needing to be dealt with beneath the application.
In most cases, proper locking depends on the U providing a method of atomic instruction stream synchronization (for example, the addition or deletion of an item into a pipeline requires that all contemporaneous operations needing to add or delete other items in the pipe be suspended during the manipulation of the memory content required to add or delete the specific item). Therefore, an application can often be more robust when it recognizes the burdens it places upon an operating system and is capable of graciously recognizing the reporting of impossible demands.[citation needed]
Lack of composability
One of lock-based programming's biggest problems is that "locks don't compose": it is hard to combine small, correct lock-based modules into equally correct larger programs without modifying the modules or at least knowing about their internals. Simon Peyton Jones (an advocate of software transactional memory) gives the following example of a banking application:[5] design a class that allows multiple concurrent clients to deposit or withdraw money to an ; and give an algorithm to transfer money from one to another. The lock-based solution to the first part of the problem is:
class :
member balance : Integer
member mutex : Lock
method deposit(n : Integer)
mutex.lock()
balance ← balance + n
mutex.unlock()
method withdraw(n : Integer)
deposit(−n)
The second part of the problem is much more complicated. A transfer routine that is correct for sequential programs would be
function transfer(from : , to : , amount : integer)
from.withdraw(amount)
to.deposit(amount)
In a concurrent program, this algorithm is incorrect because when one thread is halfway through transfer, another might observe a state where amount has been withdrawn from the first , but not yet deposited into the other : money has gone missing from the system. This problem can only be fixed completely by taking locks on both prior to changing any of the two s, but then the locks have to be taken according to some arbitrary, global ordering to prevent deadlock:
function transfer(from : , to : , amount : integer)
if from < to // arbitrary ordering on the locks
from.lock()
to.lock()
else
to.lock()
from.lock()
from.withdraw(amount)
to.deposit(amount)
from.unlock()
to.unlock()
This solution gets more complicated when more locks are involved, and the transfer function needs to know about all of the locks, so they cannot be hidden.
Language
See also: Barrier (computer science)
Programming languages vary in their for synchronization:
The ISO/IEC C standard provides a standard mutual exclusion (locks) API since C11. The current ISO/IEC C++ standard s threading facilities since C++11. The OpenMP standard is ed by some compilers, and allows critical sections to be specified using pragmas. The POSIX pthread API provides lock .[6] Visual C++ provides the synchronize attribute of methods to be synchronized, but this is specific to COM objects in the Windows architecture and Visual C++ compiler.[7] C and C++ can easily access any native operating system locking features.
Objective-C provides the keyword @synchronized[8] to put locks on blocks of code and also provides the classes NSLock,[9] NSRecursiveLock,[10] and NSConditionLock[11] along with the NSLocking protocol[12] for locking as well.
C# provides the lock keyword on a thread to ensure its exclusive access to a resource.
VB.NET provides a SyncLock keyword like C#'s lock keyword.
Java provides the keyword synchronized to lock code blocks, methods or objects[13] and libraries featuring concurrency-safe data structures.
Python provides a low-level mutex mechanism with a Lock class from the threading module.[14]
The ISO/IEC Fortran standard (ISO/IEC 1539-1:2010) provides the lock_type derived type in the intrinsic module iso_fortran_env and the lock/unlock statements since Fortran 2008.[15]
Ruby provides a low-level mutex object and no keyword.[16]
Ada provides protected objects that have visible protected subprograms or entries[17] as well as rendezvous.[18]
x86 assembly provides the LOCK prefix on certain operations to guarantee their atomicity.
PHP provides a file-based locking [19] as well as a Mutex class in the pthreads extension. [20]
In computer science, a lock or mutex (from mutual exclusion) is a synchronization mechanism for enforcing limits on access to a resource in an environment where there are many threads of execution. A lock is designed to enforce a mutual exclusion concurrency control policy.
Contents
1 Types
2 Granularity
3 Database locks
4 Disadvantages
4.1 Lack of composability
5 Language
6 See also
7 References
8 External links
Types
Generally, locks are advisory locks, where each thread cooperates by acquiring the lock before accessing the corresponding data. Some systems also implement mandatory locks, where attempting unauthorized access to a locked resource will force an exception in the entity attempting to make the access.
The simplest type of lock is a binary semaphore. It provides exclusive access to the locked data. Other schemes also provide shared access for reading data. Other widely implemented access modes are exclusive, intend-to-exclude and intend-to-upgrade.
Another way to classify locks is by what happens when the lock strategy prevents progress of a thread. Most locking designs block the execution of the thread requesting the lock until it is allowed to access the locked resource. With a spinlock, the thread simply waits ("spins") until the lock becomes available. This is efficient if threads are blocked for a short time, because it avoids the overhead of operating system process re-scheduling. It is inefficient if the lock is held for a long time, or if the progress of the thread that is holding the lock depends on preemption of the locked thread.
Locks typically require hardware for efficient implementation. This usually takes the form of one or more atomic instructions such as "test-and-set", "fetch-and-add" or "compare-and-swap". These instructions allow a single process to test if the lock is free, and if free, acquire the lock in a single atomic operation.
Uniprocessor architectures have the option of using uninterruptable sequences of instructions—using special instructions or instruction prefixes to disable interrupts temporarily—but this technique does not work for multiprocessor shared-memory machines. Proper for locks in a multiprocessor environment can require quite complex hardware or software , with substantial synchronization issues.
The reason an atomic operation is required is because of concurrency, where more than one task executes the same logic. For example, consider the following C code:
if (lock == 0) {
// lock free, set it
lock = myPID;
}
The above example does not guarantee that the task has the lock, since more than one task can be testing the lock at the same time. Since both tasks will detect that the lock is free, both tasks will attempt to set the lock, not knowing that the other task is also setting the lock. Dekker's or Peterson's algorithm are possible substitutes if atomic locking operations are not available.
Careless use of locks can result in deadlock or livelock. A number of strategies can be used to avoid or recover from deadlocks or livelocks, both at design-time and at run-time. (The most common strategy is to standardize the lock acquisition sequences so that combinations of inter-dependent locks are always acquired in a specifically defined "cascade" order.)
Some languages do locks syntactically. An example in C# follows:
public class // This is a monitor of an
{
private decimal _balance = 0;
private object _balanceLock = new object();
public void Deposit(decimal amount)
{
// Only one thread at a time may execute this statement.
lock (_balanceLock)
{
_balance += amount;
}
}
public void Withdraw(decimal amount)
{
// Only one thread at a time may execute this statement.
lock (_balanceLock)
{
_balance -= amount;
}
}
}
The code lock(this) can lead to problems if the instance can be accessed publicly.[1]
Similar to Java, C# can also synchronize entire methods, by using the MethodImplOptions.Synchronized attribute.[2][3]
[MethodImpl(MethodImplOptions.Synchronized)]
public void SomeMethod()
{
// do stuff
}
Granularity
Before being introduced to lock granularity, one needs to understand three concepts about locks:
lock overhead: the extra resources for using locks, like the memory space allocated for locks, the U time to initialize and destroy locks, and the time for acquiring or releasing locks. The more locks a program uses, the more overhead associated with the usage;
lock contention: this occurs whenever one process or thread attempts to acquire a lock held by another process or thread. The more fine-grained the available locks, the less likely one process/thread will request a lock held by the other. (For example, locking a row rather than the entire table, or locking a cell rather than the entire row.);
deadlock: the situation when each of at least two tasks is waiting for a lock that the other task holds. Unless something is done, the two tasks will wait forever.
There is a tradeoff between decreasing lock overhead and decreasing lock contention when choosing the number of locks in synchronization.
An important property of a lock is its granularity. The granularity is a measure of the amount of data the lock is protecting. In general, choosing a coarse granularity (a small number of locks, each protecting a large segment of data) results in less lock overhead when a single process is accessing the protected data, but worse performance when multiple processes are running concurrently. This is because of increased lock contention. The more coarse the lock, the higher the likelihood that the lock will stop an unrelated process from proceeding. Conversely, using a fine granularity (a larger number of locks, each protecting a fairly small amount of data) increases the overhead of the locks themselves but reduces lock contention. Granular locking where each process must hold multiple locks from a common set of locks can create subtle lock dependencies. This subtlety can increase the chance that a programmer will unknowingly introduce a deadlock.[citation needed]
In a database management system, for example, a lock could protect, in order of decreasing granularity, part of a field, a field, a record, a data page, or an entire table. Coarse granularity, such as using table locks, tends to give the best performance for a single , whereas fine granularity, such as record locks, tends to give the best performance for multiple s.
Database locks
Main article: Lock (database)
Database locks can be used as a means of ensuring transaction synchronicity. i.e. when making transaction processing concurrent (interleaving transactions), using 2-phased locks ensures that the concurrent execution of the transaction turns out equivalent to some serial ordering of the transaction. However, deadlocks become an unfortunate side-effect of locking in databases. Deadlocks are either prevented by pre-determining the locking order between transactions or are detected using waits-for graphs. An alternate to locking for database synchronicity while avoiding deadlocks involves the use of totally ordered global timestamps.
There are mechanisms employed to manage the actions of multiple concurrent s on a database—the purpose is to prevent lost updates and dirty reads. The two types of locking are pessimistic locking and optimistic locking:
Pessimistic locking: a who reads a record with the intention of updating it places an exclusive lock on the record to prevent other s from manipulating it. This means no one else can manipulate that record until the releases the lock. The downside is that s can be locked out for a very long time, thereby slowing the overall system response and causing frustration.
Where to use pessimistic locking: this is mainly used in environments where data-contention (the degree of s request to the database system at any one time) is heavy; where the cost of protecting data through locks is less than the cost of rolling back transactions, if concurrency conflicts occur. Pessimistic concurrency is best implemented when lock times will be short, as in programmatic processing of records. Pessimistic concurrency requires a persistent connection to the database and is not a scalable option when s are interacting with data, because records might be locked for relatively large periods of time. It is not appropriate for use in Web application development.
Optimistic locking: this allows multiple concurrent s access to the database whilst the system keeps a copy of the initial-read made by each . When a wants to update a record, the application determines whether another has changed the record since it was last read. The application does this by comparing the initial-read held in memory to the database record to any changes made to the record. Any discrepancies between the initial-read and the database record violates concurrency rules and hence causes the system to disregard any update request. An error message is generated and the is asked to start the update process again. It improves database performance by reducing the amount of locking required, thereby reducing the load on the database server. It works efficiently with tables that require limited updates since no s are locked out. However, some updates may fail. The downside is constant update failures due to high volumes of update requests from multiple concurrent s - it can be frustrating for s.
Where to use optimistic locking: this is appropriate in environments where there is low contention for data, or where read-only access to data is required. Optimistic concurrency is used extensively in .NET to address the needs of mobile and disconnected applications,[4] where locking data rows for prolonged periods of time would be infeasible. Also, maintaining record locks requires a persistent connection to the database server, which is not possible in disconnected applications.
Disadvantages
Lock-based resource protection and thread/process synchronization have many disadvantages:
Contention: some threads/processes have to wait until a lock (or a whole set of locks) is released. If one of the threads holding a lock dies, stalls, blocks, or enters an infinite loop, other threads waiting for the lock may wait forever.
Overhead: the use of locks adds overhead for each access to a resource, even when the chances for collision are very rare. (However, any chance for such collisions is a race condition.)
Debugging: bugs associated with locks are time dependent and can be very subtle and extremely hard to replicate, such as deadlocks.
Instability: the optimal balance between lock overhead and lock contention can be unique to the problem domain (application) and sensitive to design, implementation, and even low-level system architectural changes. These balances may change over the life cycle of an application and may entail tremendous changes to update (re-balance).
Composability: locks are only composable (e.g., managing multiple concurrent locks in order to atomically delete item X from table A and insert X into table B) with relatively elaborate (overhead) software and perfect adherence by applications programming to rigorous conventions.
Priority inversion: a low-priority thread/process holding a common lock can prevent high-priority threads/processes from proceeding. Priority inheritance can be used to reduce priority-inversion duration. The priority ceiling protocol can be used on uniprocessor systems to minimize the worst-case priority-inversion duration, as well as prevent deadlock.
Convoying: all other threads have to wait if a thread holding a lock is descheduled due to a time-slice interrupt or page fault.
Some concurrency control strategies avoid some or all of these problems. For example, a funnel or serializing tokens can avoid the biggest problem: deadlocks. Alternatives to locking include non-blocking synchronization methods, like lock-free programming techniques and transactional memory. However, such alternative methods often require that the actual lock mechanisms be implemented at a more fundamental level of the operating software. Therefore, they may only relieve the application level from the details of implementing locks, with the problems listed above still needing to be dealt with beneath the application.
In most cases, proper locking depends on the U providing a method of atomic instruction stream synchronization (for example, the addition or deletion of an item into a pipeline requires that all contemporaneous operations needing to add or delete other items in the pipe be suspended during the manipulation of the memory content required to add or delete the specific item). Therefore, an application can often be more robust when it recognizes the burdens it places upon an operating system and is capable of graciously recognizing the reporting of impossible demands.[citation needed]
Lack of composability
One of lock-based programming's biggest problems is that "locks don't compose": it is hard to combine small, correct lock-based modules into equally correct larger programs without modifying the modules or at least knowing about their internals. Simon Peyton Jones (an advocate of software transactional memory) gives the following example of a banking application:[5] design a class that allows multiple concurrent clients to deposit or withdraw money to an ; and give an algorithm to transfer money from one to another. The lock-based solution to the first part of the problem is:
class :
member balance : Integer
member mutex : Lock
method deposit(n : Integer)
mutex.lock()
balance ← balance + n
mutex.unlock()
method withdraw(n : Integer)
deposit(−n)
The second part of the problem is much more complicated. A transfer routine that is correct for sequential programs would be
function transfer(from : , to : , amount : integer)
from.withdraw(amount)
to.deposit(amount)
In a concurrent program, this algorithm is incorrect because when one thread is halfway through transfer, another might observe a state where amount has been withdrawn from the first , but not yet deposited into the other : money has gone missing from the system. This problem can only be fixed completely by taking locks on both prior to changing any of the two s, but then the locks have to be taken according to some arbitrary, global ordering to prevent deadlock:
function transfer(from : , to : , amount : integer)
if from < to // arbitrary ordering on the locks
from.lock()
to.lock()
else
to.lock()
from.lock()
from.withdraw(amount)
to.deposit(amount)
from.unlock()
to.unlock()
This solution gets more complicated when more locks are involved, and the transfer function needs to know about all of the locks, so they cannot be hidden.
Language
See also: Barrier (computer science)
Programming languages vary in their for synchronization:
The ISO/IEC C standard provides a standard mutual exclusion (locks) API since C11. The current ISO/IEC C++ standard s threading facilities since C++11. The OpenMP standard is ed by some compilers, and allows critical sections to be specified using pragmas. The POSIX pthread API provides lock .[6] Visual C++ provides the synchronize attribute of methods to be synchronized, but this is specific to COM objects in the Windows architecture and Visual C++ compiler.[7] C and C++ can easily access any native operating system locking features.
Objective-C provides the keyword @synchronized[8] to put locks on blocks of code and also provides the classes NSLock,[9] NSRecursiveLock,[10] and NSConditionLock[11] along with the NSLocking protocol[12] for locking as well.
C# provides the lock keyword on a thread to ensure its exclusive access to a resource.
VB.NET provides a SyncLock keyword like C#'s lock keyword.
Java provides the keyword synchronized to lock code blocks, methods or objects[13] and libraries featuring concurrency-safe data structures.
Python provides a low-level mutex mechanism with a Lock class from the threading module.[14]
The ISO/IEC Fortran standard (ISO/IEC 1539-1:2010) provides the lock_type derived type in the intrinsic module iso_fortran_env and the lock/unlock statements since Fortran 2008.[15]
Ruby provides a low-level mutex object and no keyword.[16]
Ada provides protected objects that have visible protected subprograms or entries[17] as well as rendezvous.[18]
x86 assembly provides the LOCK prefix on certain operations to guarantee their atomicity.
PHP provides a file-based locking [19] as well as a Mutex class in the pthreads extension. [20]
that thread never had a chance.axl2468 wrote: 521952
community/forums/topics/1116040
rip indeed.
1: make us a good thread of quality unmatchedLights wrote: 4un10
that thread never had a chance.axl2468 wrote: 521952
community/forums/topics/1116040
rip indeed.
2: hmmmm... let me think.. I have an idea!
1: what is it?
2: Let's make a thread where... guess what.
1: What?
2: People... COUNT!
1: That's brilliant, I commend you.
2: I am indeed pretty creative.
- OP and his friend probably.
Can't say he didn't try though, +1 point for trying.
Oh boy! Reforms Expert isn't doing this the first time.Winnyace wrote: 182q6t
the thread was fine until some dude came and counted from 2 to 10000. like wtf dude that's rude.
Source: "How far can we count until osu!lazer is finished?" by PancakeGD, click here.
Note: It may crash your browser.
Thread taught me some new things.Zelzatter Zero wrote: 4b5m27
community/forums/topics/1120496
Stop abraking thread, today.
Same and also futher fortified my belief that old forum is very mobile friendlyq9za wrote: 5d2e60
Thread taught me some new things.Zelzatter Zero wrote: 4b5m27
community/forums/topics/1120496
Stop abraking thread, today.
I heard a lot about old forum, is very cool.levesterz wrote: 594h69
Same and also futher fortified my belief that old forum is very mobile friendlyq9za wrote: 5d2e60
Thread taught me some new things.Zelzatter Zero wrote: 4b5m27
community/forums/topics/1120496
Stop abraking thread, today.