008.多线程-synchronized锁

深碍√TFBOYSˉ_ 2021-10-06 15:30 425阅读 0赞

为了解决线程安全问题，  
我们的做法是：不要让多个线程同时对一个全局变量作写的操作。

常用的做法就是加锁，来实现线程的同步。  
自动锁synchronized和手动锁lock。  
由于synchronized不需要手动释放锁，抛出异常也可自动释放锁。  
后面将会介绍lock锁。

一个线程拿到锁后，其他线程则只能排队，等待锁的释放。  
代码执行完毕或者程序抛出异常，锁均会被释放。

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

**synchronized 代码块**

/** * 相当于同步函数 */
        public void test1_() { 
            synchronized (this) { 
                for (int i = 1; i < 500; i++) { 
                    System.out.println("test1_..." + i);
                }
            }
        }

/** * 相当于静态同步函数 */
        public void test1s_() { 
            synchronized (Test.class) { 
                for (int i = 1; i < 500; i++) { 
                    System.out.println("test1s_..." + i);
                }
            }
        }

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

synchronized(lock-object){ 
    	}

**括号后面要跟一个对象，**  
**这个对象充当锁的作用。**  
**Java中，全部都是对象，不相同的常量字符串也是不同的对象。**

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

**同步函数： (实例对象锁)**

在方法上修饰synchronized

public synchronized void test1() { 
            for (int i = 1; i < 500; i++) { 
                System.out.println("test1..." + i);
            }
        }

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

**静态同步函数： (类对象锁)**  
方法上加上static关键字，使用synchronized 关键字修饰  
或者使用 类.class 文件。

public static synchronized void test1s() { 
            for (int i = 1; i < 500; i++) { 
                System.out.println("test1..." + i);
            }
        }

public void test1s_() { 
            synchronized (Test.class) { 
                for (int i = 1; i < 500; i++) { 
                    System.out.println("test1s_..." + i);
                }
            }
        }

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

**若类对象被锁，则类对象的所有同步方法全部被锁。**  
**若实例对象被锁，则该实例对象的所有同步方法全部被锁。**  
**不是同一个对象，实例对象锁没有约束。**

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

**synchronized代码块的优势：**

1.  只对需要同步的代码进行同步
2.  与wait() 、notify() 、notifyAll() 一起使用时，比较方便

package cn.qbz.thread;
    
    public class WaitNotifyTest { 
    
    
        public static void main(String[] args) { 
            new Thread(new Produce()).start();
            new Thread(new Consumer()).start();
        }
    }
    
    class Produce implements Runnable { 
    
        public void run() { 
            int count = 5;
            while (count > 0) { 
                synchronized ("lock-object") {  //此处可以锁定任何对象，只要锁定Produce和Consumer中的对象一样
                    System.out.println("A");
                    count--;
                    "lock-object".notify();// 唤醒因为调用对象的wait()而等待的线程
    
                    if (count > 0) { 
                        try { 
                            "lock-object".wait();//释放本线程的对象锁，释放CPU
                        } catch (InterruptedException e) { 
                            e.printStackTrace();
                        }
                    }
                }
            }
    
        }
    
    }
    
    class Consumer implements Runnable { 
    
        public void run() { 
            int count = 5;
            while (count > 0) { 
                synchronized ("lock-object") { 
    
                    System.out.println("B");
                    count--;
                    "lock-object".notify(); // 唤醒因为调用对象的wait()而等待的线程
    
                    if (count > 0) { 
                        try { 
                            "lock-object".wait(); //释放本线程的对象锁，释放CPU
                        } catch (InterruptedException e) { 
                            e.printStackTrace();
                        }
                    }
                }
            }
        }
    }

![idea64_2018-11-15_13-43-09.png][]

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

**wait():**  
释放占有的对象锁，线程进入等待池，释放cpu。  
其他正在等待的线程即可抢占此锁，获得锁的线程即可运行程序。  
**sleep():**  
线程休眠，休眠期间，释放cpu，但不释放占有的对象锁。  
即：休眠期间，其他线程依然无法进入此同步代码块内。  
**notify():**  
唤醒因为调用对象的wait()而等待的线程。  
调用notify()后，并不会立即释放锁，  
而是直到synchronized代码块中全部执行完毕，才释放锁。  
JVM会在等待的线程中调度一个线程去获得此锁，执行代码。  
**notifyAll()**  
唤醒所有等待的线程。

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

**notify与notifyAll**  
**锁池：**  
假设线程A已经拥有了某个对象锁（非类锁），  
此时想获取此对象锁的其他线程，将进入此对象的锁池中，  
参与下次锁的竞争。  
**等待池：**  
假设线程A调用了对象锁的wait()方法，  
线程A会释放该对象锁，并进入此对象的等待池中。  
等待池中的线程不会参与对象锁的竞争。  
**notify调用后，只会将等待池中的一个随机线程移到锁池中。**  
**notifyAll调用后，会将全部线程移到锁池中。**

notify有一定几率造成死锁。

[idea64_2018-11-15_13-43-09.png]: http://upyun.qubianzhong.cn/picture/idea64_2018-11-15_13-43-09.png