Java多线程学习总结（四）

Java多线程学习总结（四）

——2020.02.24学习总结

1.线程间的通信

wait()和notifyAll()的应用实例：

package com.Zhongger.Day05;

/**
 * @Author Zhongger
 * @Description 有两个线程，可以操作初始值为0的一个变量，实现一个线程对该变量加1，一个对该变量减1，实现交替，来10轮
 * @Date 2020.2.24 生产者消费者模式
 */
public class TheadWaitNotifyTest {
    public static void main(String[] args) {
        AirConditioner airConditioner = new AirConditioner();
        new Thread(()->{
            for (int i = 1; i <= 10; i++) {
                try {
                    airConditioner.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();
        new Thread(()->{
            for (int i = 1; i <= 10; i++) {
                try {
                    airConditioner.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"B").start();
    }
}
class AirConditioner
{
    private int number=0;
    public synchronized void increment() throws InterruptedException {
        //1.判断
        if (number!=0){
            this.wait();
        }
        //2.干活
        number++;
        System.out.println(Thread.currentThread().getName()+"\t"+number);
        //3.通知
        this.notifyAll();
    }
    public synchronized void decrement() throws InterruptedException {
        if (number==0){
            this.wait();
        }
        number--;
        System.out.println(Thread.currentThread().getName()+"\t"+number);
        this.notifyAll();
    }
}

运行结果为：

在这其中，用到了生产者消费者模式
生产者消费者模式说明：

• 生产者只在仓库未满时进行生产，仓库满时生产者进程被阻塞；
• 消费者只在仓库非空时进行消费，仓库为空时消费者进程被阻塞；
• 当生产者发现仓库满时会通知消费者消费；

A相当于一个生产者，B相当于一个消费者。
现在，如果多加入两个线程，看看程序的运行结果会怎么样？

可以发现，A，C作为生产者，生产的物品多于了1。如果在真正的生产环境中出现这样的问题，会造成难以挽回的后果。所以一定要避免这种情况。
即在多线程交互中，必须要防止多线程的虚假唤醒。解决方案是：判断的地方使用whlie循环

	whlie(number!=0){
        this.wait();
    }

另外，使用ReentrantLock的方式也是可以的，在前两天的博客中有写到。

2.多线程间按顺序调用

package com.Zhongger.Day05;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @Author Zhongger
 * @Description 多线程间按顺序调用，实现A->B->C，A打印5次，B打印10次，C打印15次
 * @Date 2020.2.24
 */
public class ThreadOrderAccess {
    public static void main(String[] args) {
        ShareResource shareResource = new ShareResource();
        new Thread(()->{
            for (int i = 0; i < 3; i++) {
                shareResource.print5();
            }

        },"A").start();

        new Thread(()->{
            for (int i = 0; i < 3; i++) {
                shareResource.print10();
            }

        },"B").start();

        new Thread(()->{
            for (int i = 0; i < 3; i++) {
                shareResource.print15();
            }

        },"C").start();
    }
}
//资源类
class ShareResource{
    private int number=1;//1:A 2:B 3:C
    private Lock lock = new ReentrantLock();
    private Condition condition1=lock.newCondition();
    private Condition condition2=lock.newCondition();
    private Condition condition3=lock.newCondition();
    public void print5(){
        lock.lock();
        try {
            //判断
            while (number!=1){
                condition1.await();
            }
            //干活
            for (int i = 1; i <= 5; i++) {
                System.out.println(Thread.currentThread().getName()+"\t"+i);
            }
            //通知
            number=2;
            condition2.signal();//唤醒了B线程
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }

    }

    public void print10(){
        lock.lock();
        try {
            //判断
            while (number!=2){
                condition2.await();
            }
            //干活
            for (int i = 1; i <= 10; i++) {
                System.out.println(Thread.currentThread().getName()+"\t"+i);
            }
            //通知
            number=3;
            condition3.signal();//唤醒了线程C
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }

    }

    public void print15(){
        lock.lock();
        try {
            //判断
            while (number!=3){
                condition3.await();
            }
            //干活
            for (int i = 1; i <= 15; i++) {
                System.out.println(Thread.currentThread().getName()+"\t"+i);
            }
            //通知
            number=1;
            condition1.signal();//唤醒了线程A
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }

    }
}

使用多个Condition和Signal来精准地通知下一个线程工作。

3.多线程八锁

1.如果一个对象里面有多个synchronized方法，某一时刻内，只要有一个线程去调用其中的一个synchronized方法了，其他线程都只能等待，换句话说，某一时刻内，只能有一个线程去访问这些synchronized方法，synchronized锁的是一个当前对象this，被锁定后，其他的线程都不能进入到当前对象的其他synchronized方法。
2.类中如果有普通方法，和同步锁无关，其他线程可以访问。
3.若有两个资源类对象，锁是不同的，所以不同的线程可以访问不同的资源类对象中的synchronized方法，互不干扰。
4.所有的非静态同步方法都是同一把锁——类的实例。
5.synchronized实现同步的基础：Java中的每一个对象都可以作为锁，具体表现为以下三种形式：

• 对于普通的同步方法，锁是当前实例对象
• 对于静态同步方法，锁是当前类的Class对象
• 对于同步方法块，锁是synchronized括号里配置的对象

6.当一个线程试图访问同步代码块时，它必须得到锁，退出或抛出异常时必须释放锁。
7.所有的静态同步方法都是同一把锁——类的Class对象
8.静态同步方法和普通同步方法锁的是不同的对象，两个方法之间是不会有竞争条件的，但是一旦一个静态同步方法获取锁后，其他的静态同步方法都必须等待该方法释放锁后才能获取锁，而不管是同一个实例对象的静态同步方法之间，还是不同的实例对象的静态同步方法之间，只要它们是同一个类的实例对象。

好了，今天的多线程学习就到这里，明天继续咯~