目录Java中的锁1.synchronized锁（jvm层的解决方案，也叫监视器锁）2.手动锁Locksynchronized锁synchronized使用场景1.使用synchronized来修饰代码块（可以给任意的对象进行加锁操作）2.使用synchronized来修饰静态方法（对当前的类进行加锁的操作）3.使用synchronized来修饰普通的方法(对当前类的实例来进行加锁）synchronized注意事项1.加锁的时候一定要使用同一把锁对象Lock锁使用的注意事项公平锁、非公平锁synchronzied 和 Lock 的区别死锁造成死锁的四个条件死锁的解决方案线程间通信wait/notify机制的原理notifyAllwait()和sleep()的区别线程使用wait()的时候它就会释放掉锁。sleep(0) 和wait(0)的区别：LockSupport park()/unpark()总结
Java中的锁
Java中的加锁操作有两种：
1.synchronized锁（jvm层的解决方案，也叫监视器锁）
在操作系统的层面使用的是互斥锁(mutex lock)
在Java中放在了对象头中。
2.手动锁Lock
操作锁的流程
1.尝试获取锁 2.使用锁 3.释放锁
synchronized锁
package ThreadDeom;/** * user：ypc； * date：2021-06-12; * time: 14:12; */class Counter2 { private static volatile int count = 0; public void increase() { for (int i = 0; i < 10000; i++) { count++; } } public void decrease() { for (int i = 0; i < 10000; i++) { count--; } } public int getCount() { return count; }}public class ThreadDemo19 { public static void main(String[] args) throws InterruptedException { //声明锁对象，任何的对象都可以作为锁 Object lock = new Object(); Counter2 counter2 = new Counter2(); Thread thread1 = new Thread(new Runnable() { @Override public void run() { //使用锁 synchronized (lock) { counter2.decrease(); } } }); Thread thread2 = new Thread(() -> { synchronized (lock) { counter2.increase(); } }); thread1.start(); thread2.start(); thread1.join(); thread2.join(); System.out.println(counter2.getCount()); }}
结果是：
synchronized使用场景
1.使用synchronized来修饰代码块（可以给任意的对象进行加锁操作）
public class ThreadDemo19 { public static void main(String[] args) throws InterruptedException { //声明锁对象，任何的对象都可以作为锁 Object lock = new Object(); Counter2 counter2 = new Counter2(); Thread thread1 = new Thread(new Runnable() { @Override public void run() { //使用锁 synchronized (lock) { counter2.decrease(); } } }); Thread thread2 = new Thread(() -> { synchronized (lock) { counter2.increase(); } }); thread1.start(); thread2.start(); thread1.join(); thread2.join(); System.out.println(counter2.getCount()); }}
2.使用synchronized来修饰静态方法（对当前的类进行加锁的操作）
package ThreadDeom;/** * user：ypc； * date：2021-06-12; * time: 14:02; */class Counter1 { private static volatile int count = 0; public void increase() { for (int i = 0; i < 10000; i++) { count++; } } public void decrease() { for (int i = 0; i < 10000; i++) { count--; } } public int getCount() { return count; }}public class ThreadDemo18 { public static void main(String[] args) throws InterruptedException { Counter1 counter1 = new Counter1(); Thread thread1 = new Thread(new Runnable() { @Override public void run() { counter1.decrease(); } }); Thread thread2 = new Thread(() -> { counter1.increase(); }); thread1.start(); thread2.start(); thread1.join(); thread2.join(); System.out.println(counter1.getCount()); }}
3.使用synchronized来修饰普通的方法(对当前类的实例来进行加锁）
package ThreadDeom;/** * user：ypc； * date：2021-06-12; * time: 14:12; */public class ThreadDemo20 { private static int num = 0; private static final int maxSize = 100000; public static void main(String[] args) throws InterruptedException { ThreadDemo20 threadDemo20 = new ThreadDemo20(); Thread thread1 = new Thread(new Runnable() { @Override public void run() { threadDemo20.increase(); } }); Thread thread2 = new Thread(new Runnable() { @Override public void run() { threadDemo20. decrease(); } }); thread1.start(); thread2.start(); thread1.join(); thread2.join(); System.out.println(num); } //给静态的方法进行加锁，被加的锁是当前的对象。// public synchronized static void increase(){ //给普通的方法进行加锁的操作 public synchronized void increase() { for (int i = 0; i < maxSize; i++) { num++; } } // public synchronized static void decrease(){ public synchronized void decrease() { for (int i = 0; i < maxSize; i++) { num--; } }}
synchronized注意事项
1.加锁的时候一定要使用同一把锁对象
Lock类的使用
也叫手动锁
package ThreadDeom;import java.util.concurrent.locks.Lock;import java.util.concurrent.locks.ReentrantLock;/** * user：ypc； * date：2021-06-12; * time: 18:32; */public class ThreadDemo22 { private static int number = 0; private static final int maxSize = 100000; public static void main(String[] args) { //创建lock锁对象，lock是接口，不能实列化 Lock lock = new ReentrantLock(); Thread thread1 = new Thread(() -> { for (int i = 0; i < maxSize; i++) { lock.lock(); try { number++; } finally { lock.unlock(); } } }); Thread thread2 = new Thread(() -> { for (int i = 0; i < maxSize; i++) { lock.lock(); try { number--; } finally { lock.unlock(); } } }); System.out.println(number); }}
Lock锁使用的注意事项
lock()操作一定要放在try外面
如果放在try的里面：
1.try中抛出了异常，还没有加锁就释放了finally中的锁的操作了
2.如果放在了try，没加锁就释放了锁，就会抛出异常，就会将业务代码中的异常吞噬掉👇如果一定要放的话，将lock()放在try的第一行。
package ThreadDeom;import java.util.concurrent.locks.Lock;import java.util.concurrent.locks.ReentrantLock;/** * user：ypc； * date：2021-06-12; * time: 18:49; */public class ThreadDemo23 { public static void main(String[] args) { Lock lock = new ReentrantLock(); try{ System.out.println(1/0); lock.lock(); } finally { lock.unlock(); } }}
公平锁、非公平锁
公平锁的调度：
一个线程释放锁。
主动唤醒“需要得到锁”的队列来得到锁。
非公平锁
当一个线程释放锁之后，另一个线程刚好执行到获取锁的代码就可以直接获取锁。
Java中的所有锁默认都是非公平锁。
非公平锁的性能更高。
ReentrantLock可以设置非公平锁。
公平锁
package ThreadDeom;import java.util.concurrent.locks.ReentrantLock;/** * user：ypc； * date：2021-06-12; * time: 19:22; */public class ThreadDemo24 { public static void main(String[] args) throws InterruptedException { ReentrantLock reentrantLock = new ReentrantLock(); Thread thread1 = new Thread(() -> { for (int i = 0; i < 100; i++) { reentrantLock.lock(); try { System.out.println("thread1"); } finally { reentrantLock.unlock(); } } }); Thread thread2 = new Thread(() -> { for (int i = 0; i < 100; i++) { reentrantLock.lock(); try { System.out.println("thread2"); } finally { reentrantLock.unlock(); } } }); Thread.sleep(100); thread1.start(); thread2.start(); }}
打印的结果是无序的
如果设置为公平锁：👇
thread1和thread2 交替输出
synchronzied 和 Lock 的区别
1.synchronzied可以自动的进行加锁和释放锁，而Lock需要手动的加锁、释放锁。
2.Lock是Java层面的锁实现，而synchronzied 是JVM层面锁的实现
3.synchronzed 即可以修饰代码块，又可以修饰普通方法和静态的方法，而Lock 只能修饰代码块
4.synchronized 实现的是 非公平的锁，而Lock 可以实现公平锁。
5.lock的灵活性更高
死锁
在两个或两个以上的线程运行中，因为资源的抢占而造成线程一直等待的问题。看👇：
package ThreadDeom;/** * user：ypc； * date：2021-06-12; * time: 19:48; */public class ThreadDemo25 { public static void main(String[] args) throws InterruptedException { Object lockA = new Object(); Object lockB = new Object(); Thread thread1 = new Thread(() -> { synchronized (lockA) { System.out.println(Thread.currentThread().getName() + "获取到lockA"); //让线程2获取lockB try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } synchronized (lockB) { System.out.println(Thread.currentThread().getName() + "获取到lockB"); } } }); Thread thread2 = new Thread(new Runnable() { @Override public void run() { //线程2获取资源B synchronized (lockB) { System.out.println(Thread.currentThread().getName() + "获取到lockB"); //让线程1先获取到锁lockA try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } synchronized (lockA) { System.out.println(Thread.currentThread().getName() + "获取到lockA"); } } } }); thread1.start(); thread2.start(); }}
这就造成了死锁
造成死锁的四个条件
1.互斥条件：
当资源被一个线程拥有之后，就不能被其它的线程拥有了
2.拥有请求条件：
当一个线程拥有了一个资源之后，又试图请求另一个资源。
3.不可剥夺条件:
当一个线程拥有了一个资源之后，如果不是这个线程主动的释放资源，其他线程就不能拥有这个线程。
4.环路等待条件：
两个或两个以上的线程拥有了资源之后，试图获取对方的资源的时候形成了一个环路。
死锁的解决方案
解决请求拥有和环路等待。
最有效的解决方案就是控制加锁的顺序。
package ThreadDeom;/** * user：ypc； * date：2021-06-12; * time: 20:25; */public class ThreadDemo26 { public static void main(String[] args) throws InterruptedException { Object lockA = new Object(); Object lockB = new Object(); Thread thread1 = new Thread(() -> { synchronized (lockA) { System.out.println(Thread.currentThread().getName() + "获取到lockA"); //让线程2获取lockB try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } synchronized (lockB) { System.out.println(Thread.currentThread().getName() + "获取到lockB"); } } }); Thread thread2 = new Thread(new Runnable() { @Override public void run() { synchronized (lockA) { System.out.println(Thread.currentThread().getName() + "获取到lockA"); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } synchronized (lockB) { System.out.println(Thread.currentThread().getName() + "获取到lockB"); } } } }); thread1.start(); thread2.start(); }}
线程间通信
线程之间的通讯是指在一个线程中的操作可以影响另一个线程。
wait/notify机制的原理
拥有相同锁的线程之间才能使用wait/notify机制。
wait()是Object()的方法，它的作用是是当前执行wait()方法的线程等待，在wati（）所在的代码出停止执行，并释放锁，直到接到通知或者被中断为止。即在调用wait()的方法之前，线程必需先获取到对象级别的锁，也就是只能在同步方法或者同步块中使用wait()方法。
如果在使用wait（）方法之前线程没有获得相应的锁，那么程序在执行时就会抛出异常。
notify()方法要在同步方法或者同步块中执行，即在调用notify（）方法之前，线程必需要先获取到锁对象。如果线程没有持有锁对象的话，那么也会抛出异常。该方法用来通知可能在等待该锁的其它线程，如果有多个线程，那么则按照执行wait（）方法的顺序来对处于wait（）方法的线程发出通知，并使该线程重新获取锁。执行notify（）方法之后，当前线程不会马上释放锁，处于wait（）状态的线程也不会立马得到这个对象锁。而是要等notify的synchronized同步区域执行完成之后才会释放锁，处于wait()状态的线程才会得到锁对象。
总结：wait()方法用于让线程停止运行，而notify()方法用于通知暂停的线程继续运行。
在使用wait()或者notify()方法之前没有对象锁，就会报异常👇：
lock.notify();
正确的使用之后
package ThreadDeom;/** * user：ypc； * date：2021-06-12; * time: 21:11; */public class ThreadDemo27 { //设置锁对象 private static Object lock = new Object(); public static void main(String[] args) throws InterruptedException { Thread thread = new Thread(new Runnable() { @Override public void run() { synchronized (lock) { System.out.println("在wait()"); try { lock.wait(); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("被notify()唤醒之后"); } } }); thread.start(); Thread.sleep(1000); synchronized (lock) { lock.notify(); } }}
注意：使用wait()方法的时候一定要和线程的锁对象是一个锁。
notifyAll
在多线程的情况下使用notify()方法只可以唤醒一个线程👇
package ThreadDeom;/** * user：ypc； * date：2021-06-13; * time: 8:06; */public class ThreadDemo28 { //设置锁对象 private static Object lock = new Object(); public static void main(String[] args) throws InterruptedException { Thread thread1 = new Thread(new Runnable() { @Override public void run() { synchronized (lock) { System.out.println("thread1在wait()"); try { lock.wait(); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("thread1被notify()唤醒之后"); } } }); Thread thread2 = new Thread(() -> { synchronized (lock) { System.out.println("thread2在wait()"); try { lock.wait(); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("thread2被notify()唤醒之后"); } }); Thread thread3 = new Thread(new Runnable() { @Override public void run() { synchronized (lock) { System.out.println("thread3在wait()"); try { lock.wait(); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("thread3被notify()唤醒之后"); } } }); thread1.start(); thread2.start(); thread3.start(); Thread.sleep(1000); synchronized (lock) { System.out.println("主线程调用notify()之后"); lock.notify(); } }}
那么如果使用notifyAll()方法呢？
可以看到所有的线程都被唤醒了
那么使用notify()唤醒的线程有没有什么顺序呢？
使用notify()唤醒线程的顺序是正序、倒序、还是随机的，这取决与JVM的具体实现，并不是所有的JVM在执行notify()时都是按照wait（）的执行顺序进行唤醒的，也不是所有的notidyAll()都是按照wait()方法的倒序进行唤醒的，这取决于JVM的具体实现。
wait()和notify()不能唤醒指定的线程。
wait()和sleep()的区别
也可以让wait()等待指定的时间,如果超过给定的时间，wait()不会无限期的等待下去.
没有被notify()唤醒，过了1000毫秒之后会自动停止。
wait()在不传入任何参数的时候，线程会进入waiting 的状态，而在wait()中加入一个大于0的参数的时候，线程会进入time_wating的状态。
sleep()和wait()的区别 : 线程在sleep（）的时候是不会释放锁的，而执行wait()的时候它就会释放锁。👇：
package ThreadDeom;import jdk.nashorn.internal.ir.Block;/** * user：ypc； * date：2021-06-13; * time: 8:45; */public class ThreadDemo29 { private static Object lock = new Object(); public static void main(String[] args) throws InterruptedException { Thread thread = new Thread(new Runnable() { @Override public void run() { synchronized (lock) { try { System.out.println("thread获取到了锁"); //如果sleep释放锁的话，会在thread获取到了锁和thread释放了锁之间打印 Thread.sleep(3000); } catch (InterruptedException e) { e.printStackTrace(); } } System.out.println("thread释放了锁"); } }); thread.start(); //让thread 先获取到锁 Thread.sleep(1000); synchronized (lock) { System.out.println("主线程获取到了锁"); } }}
可以看到线程在sleep()的时候，线程是不会释放锁的。再来看看wait()方法👇：
线程使用wait()的时候它就会释放掉锁。
1.wait(）和sleep()都是让线程进行休眠的
2.wait()和sleep()方法都有可能在执行的过程接收到线程终止的通知
3.wait()必须和synchronzied一起使用，而sleep()不用。
4.wait（）会释放锁，而sleep()不会释放锁。
5.wait()时Object的方法，而sleep()时Thread的方法。
6.默认情况下，wait()不传任何的参数的情况下，wait()会进入waiting的状态，如果传递了参数，wait()会进入time_waiting的状态。而sleep()进入的是time_waiting的状态。
sleep(0) 和wait(0)的区别：
1.sleep(0)表示0毫秒之后继续执行，而wait(0)表示线程会一直休眠下去wait(0)和wait()是一样的，wait()的源码就是调用了wait(0）方法。
2.sleep(0)表示重新出发一次CPU的竞争。
为什么wait()会释放锁，而sleep()不会释放锁？
sleep（）需要传递一个最大的等待时间，也就是说sleep()是可控的，而wait()是不可以传递参数的，从设计的层面来说，如果让wait()一直持有所得话，那么线程就可能一直阻塞。
为什么wait(）是Object的方法，而sleep（）是线程的方法?
wait()需要操作锁，而锁是属于对象级别的，所有的锁都是放在对象头中的，它不是线程级别的，一个线程可以有多把的锁，为了灵活，就将wait()放在Object中了。
LockSupport park()/unpark()
使用LockSupport可以解决wait()/notify()随机唤醒的问题。
package ThreadDeom;import java.util.concurrent.locks.LockSupport;/** * user：ypc； * date：2021-06-13; * time: 9:36; */public class ThreadDemo30 { public static void main(String[] args) { Thread thread1 = new Thread(new Runnable() { @Override public void run() { //让线程休眠 LockSupport.park(); System.out.println("unPark()了thread1"); } }); Thread thread2 = new Thread(() -> { LockSupport.park(); System.out.println("unPark()了thread2"); }); Thread thread3 = new Thread() { @Override public void run() { LockSupport.park(); System.out.println("unPark()了thread3"); } }; thread1.start(); thread2.start(); thread3.start(); LockSupport.unpark(thread1); LockSupport.unpark(thread2); }}
总结
本篇文章就到这里了，希望可以帮助到你，也希望您能够多多关注的更多内容！
黄色蓝色或者砖红色，犹如童话世界。
