Method 1: Use the synchronized keyword
Since each object in Java has a built-in lock, when using this keyword to modify the method , a built-in lock protects the entire method. Before calling this method, you need to obtain the built-in lock, otherwise it will be blocked.
Note: The synchronized keyword can also modify a static method. If the static method is called at this time, the entire class will be locked.
Note: Synchronization is a high-cost operation, so the content of synchronization should be minimized. Usually there is no need to synchronize the entire method, just use synchronized code blocks to synchronize key code.
The synchronized keyword is used to protect shared data. Please pay attention to "shared data", you must distinguish which data is shared data
Related video tutorial recommendation:java video
Example:
package com.gcc.interview.synchro;
public class MybanRunnable implements Runnable{
private Bank bank;
public MybanRunnable(Bank bank) {
this.bank = bank;
}
@Override
public void run() {
for(int i=0;i<10;i++) {
bank.save1(100);
System.out.println("账户余额是---"+bank.getAccount());
}
}
}package com.gcc.interview.synchro;
class Bank{
private int account = 100;
public int getAccount() {
return account;
}
//同步方法
public synchronized void save(int money) {
account+=money;
}
public void save1(int money) {
//同步代码块
synchronized(this) {
account+=money;
}
}
public void userThread() {
Bank bank = new Bank();
MybanRunnable my1 = new MybanRunnable(bank);
System.out.println("线程1");
Thread th1 = new Thread(my1);
th1.start();
System.out.println("线程2");
Thread th2 = new Thread(my1);
th2.start();
}
}Method 2: wait and notify
wait(): puts a thread in a waiting state and releases the lock of the object it holds.
sleep(): Puts a running thread into sleep state. It is a static method. Call this method to catch InterruptedException.
notify(): Wake up a thread in the waiting state. Note that when calling this method, you cannot exactly wake up a thread in the waiting state. Instead, the JVM determines which thread to wake up, and Not by priority.
Allnotity(): Wake up all threads in the waiting state. Note that you do not give all awakened threads an object lock, but let them compete.
Method 3: Use special domain variable volatile to achieve thread synchronization
a.volatile keyword provides a lock-free mechanism for domain variable access
b. Using volatile to modify a field is equivalent to telling the virtual machine that the field may be updated by other threads
c. Therefore, each time the field is used, it must be recalculated instead of using the value in the register
d.volatile does not provide any atomic operations, nor can it be used to modify final type variables
For example:
In the above example, just add in front of account Volatile modification can achieve thread synchronization.
//只给出要修改的代码，其余代码与上同
class Bank {
//需要同步的变量加上volatile
private volatile int account = 100;
public int getAccount() {
return account;
}
//这里不再需要synchronized
public void save(int money) {
account += money;
}
｝Note: The non-synchronization problem in multi-threading mainly occurs in reading and writing to the domain. If the domain itself avoids this problem, there is no need to modify the method of operating the domain. Using final fields, lock-protected fields and volatile fields can avoid non-synchronization problems.
Method 4: Use reentrancy locks to achieve thread synchronization
A new java.util.concurrent package has been added in JavaSE5.0 to support synchronization.
The ReentrantLock class is a reentrant, mutually exclusive lock that implements the Lock interface. It has the same basic behavior and semantics as using synchronized methods and blocks, and extends its capabilities.
Commonly used methods of the ReenreantLock class are:
Note: ReentrantLock() also has a construction method that can create a fair lock, but because it can greatly reduce Program running efficiency, not recommended
private int account = 100;
private ReentrantLock lock = new ReentrantLock();
public int getAccount() {
return account;
}
//同步方法
public void save(int money) {
lock.lock();
try {
account+=money;
} finally {
lock.unlock();
}
}Note: Regarding the selection of Lock object and synchronized keyword:
a. It is best to use neither of them and use a java.util.concurrent package The mechanism provided can help users handle all lock-related codes.
b. If the synchronized keyword can meet the needs of users, use synchronized because it can simplify the code
c. If more advanced functions are needed, use the ReentrantLock class. At this time, Pay attention to releasing the lock in time, otherwise deadlock will occur. Usually the lock is released in the finally code
Method 5: Use local variables to achieve thread synchronization
If you use ThreadLocal to manage variables , then each thread using the variable obtains a copy of the variable, and the copies are independent of each other, so that each thread can modify its own copy of the variable at will without affecting other threads.
Commonly used methods of the ThreadLocal class
//只改Bank类，其余代码与上同
public class Bank{
//使用ThreadLocal类管理共享变量account
private static ThreadLocal<Integer> account = new ThreadLocal<Integer>(){
@Override
protected Integer initialValue(){
return 100;
}
};
public void save(int money){
account.set(account.get()+money);
}
public int getAccount(){
return account.get();
}
}Note: ThreadLocal and synchronization mechanism
a.ThreadLocal and synchronization mechanism are both to solve multiple problems Access conflict problem of the same variable in threads.
b. The former adopts the method of "exchanging space for time", and the latter adopts the method of "exchanging time for space".
Recommended related articles and tutorials: zero basic introduction to java
The above is the detailed content of How to implement thread synchronization in java. For more information, please follow other related articles on the PHP Chinese website!