彻底搞懂Java多线程(二)

目录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获取lockBtry { 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获取资源Bsynchronized (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获取lockBtry { 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); }}

总结

本篇文章就到这里了，希望可以帮助到你，也希望您能够多多关注好吧啦网的更多内容！