Java study 多线程(死锁, Lock锁, 生产者消费者问题, 管程法, 信号灯法)

💛死锁

死锁是指两个或两个以上的进程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程。

package com.smile.test.thread;

public class DeadLock {
    public static void main(String[] args) {
        MakeUp mk1 = new MakeUp(0, "小红");
        MakeUp mk2 = new MakeUp(1, "小黑");
        new Thread(mk1).start();
        new Thread(mk2).start();
    }

}
// 镜子对象
class Mirror{

}
// 口红对象
class LipStick{

}
// 化妆
class MakeUp implements Runnable{
    static Mirror mirror = new Mirror();
    static LipStick lipstick = new LipStick();
    int choice; // 第一次选择的
    String userName; // 化妆的人
    // 有参构造
    public MakeUp(int choice, String userName) {
        this.choice = choice;
        this.userName = userName;
    }

    @Override
    public void run() {
        try {
            makeup();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    private void makeup() throws InterruptedException {
        if (choice == 0) {
            synchronized (mirror){
                System.out.println(this.userName + "获得了Mirror");
                Thread.sleep(1000);
                synchronized(lipstick){
                    System.out.println(this.userName + "获得了LipStick");
                }
            }
        }else {
            synchronized (lipstick){
                System.out.println(this.userName + "获得了LipStick");
                Thread.sleep(1000);
                synchronized(mirror){
                    System.out.println(this.userName + "获得了Mirror");
                }
            }
        }
        /*
        不会引起死锁
        private void makeup() throws InterruptedException {
        if (choice == 0) {
            synchronized (mirror){
                System.out.println(this.userName + "获得了Mirror");
                Thread.sleep(1000);
            }
            synchronized(lipstick){
                System.out.println(this.userName + "获得了LipStick");
            }
        }else {
            synchronized (lipstick){
                System.out.println(this.userName + "获得了LipStick");
                Thread.sleep(1000);
            }
            synchronized(mirror){
                System.out.println(this.userName + "获得了Mirror");
            }
        }
    }
        */
    }
}

虽然进程在运行过程中，可能发生死锁，但死锁的发生也必须具备一定的条件，死锁的发生必须具备以下四个必要条件。

• 互斥条件：指进程对所分配到的资源进行排它性使用，即在一段时间内某资源只由一个进程占用。如果此时还有其它进程请求资源，则请求者只能等待，直至占有资源的进程用毕释放。

• 请求和保持条件：指进程已经保持至少一个资源，但又提出了新的资源请求，而该资源已被其它进程占有，此时请求进程阻塞，但又对自己已获得的其它资源保持不放。

• 不剥夺条件：指进程已获得的资源，在未使用完之前，不能被剥夺，只能在使用完时由自己释放。

• 环路等待条件：指在发生死锁时，必然存在一个进程——资源的环形链，即进程集合{P0，P1，P2，···，Pn}中的P0正在等待一个P1占用的资源；P1正在等待P2占用的资源，……，Pn正在等待已被P0占用的资源。

解决死锁:

• 只需要破坏四个必要条件任意之一, 都能避免死锁的问题.

💛Lock锁

• JDK5.0开始, java提供了更强大的同步机制------通过显示的定义同步锁对象来实现同步. 同步锁使用Lock对象充当.
• java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具. Lock锁提供了对共享资源的独立访问, 每次只能有一个线程对Lock对象加锁, 线程开始访问共享资源之前应先获得Lock对象.
• ReentrantLock是Lock 的一个实现类, 拥有与synchronized相同的并发性和内存语义, 在实际线程的安全控制中,比较常用的是ReentrantLock, 可以显示的加锁, 释放锁.

package com.smile.test.thread.unsafethread;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.locks.ReentrantLock;

public class UnSafeArrayList {
    public static void main(String[] args) throws InterruptedException {
        List<String> list = new ArrayList<String>();
        ReentrantLock lock = new ReentrantLock();
            for (int i = 0; i < 5000; i++) {
                new Thread(()->{
                    lock.lock();
                    list.add(Thread.currentThread().getName());
                    lock.unlock();
                }).start();
            }
            Thread.sleep(3000);
        System.out.println(list.size());
    }
}

• Lock锁是显示锁(调用lock()加锁, 调用unlock()释放锁)
• synchronized锁是隐式锁, 除了作用域自动释放.
• Lock锁只有代码块锁, synchronized有代码块锁和方法锁.
• 使用Lock锁,JVM花更少的时间调度线程, 性能更好, 并且有更好的扩展性(有很多实现类).

💛生产者消费者问题

💛管程法

package com.smile.test.thread;

/**
 * 管程法
 * @author 62741
 */
public class testPC {
    public static void main(String[] args) {
        SynContainer synContainer = new SynContainer();
        new Product(synContainer).start();
        new Consumer(synContainer).start();
    }

}
// 生产者
 class Product extends Thread{
    SynContainer synContainer;
    public Product(SynContainer synContainer){
        this.synContainer = synContainer;
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            try {
                synContainer.push(new Chicken(i));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Product" + i + "Chicken");
        }
    }
}
// 消费者
class Consumer extends Thread{
    SynContainer synContainer;
    public Consumer(SynContainer synContainer){
        this.synContainer = synContainer;
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            synContainer.pop();
            System.out.println("Consumer" + synContainer.pop().id + "Chicken");
        }
    }
}
class Chicken{
    int id;

    public Chicken(int id) {
        this.id = id;
    }
}
class SynContainer{
    Chicken[] chickens = new Chicken[10];
    int count = 0;
    public synchronized void push(Chicken chicken) throws InterruptedException {
        if (count == chickens.length){
            // 容器满了,通知消费者消费,生产者等待
            this.wait();
        }
        chickens[count] = chicken;
        count++ ;
        this.notifyAll();

    }
    public synchronized Chicken pop(){
        if (count == 0){
            // 容器空,通知生产者生产,消费者等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        count--;
        Chicken chicken = chickens[count];
        this.notifyAll();
        return chicken;
    }
}

💛信号灯法

package com.smile.test.thread;

public class SingnalMothod {
    public static void main(String[] args) {
        Play play = new Play();
        new Actor(play).start();
        new Watcher(play).start();
    }
}
class Actor extends Thread{
    Play play;
    public Actor(Play play){
        this.play = play;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            if (i%2 == 0){
                play.play("第" + i + "集");
            } else {
                play.play("广告播放中...");
            }
        }
    }
}
class Watcher extends Thread{
    Play play;
    public Watcher(Play play){
        this.play = play;
    }
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            play.watch();
        }
    }
}

class Play{
    String program;
    boolean flag = true;

    public synchronized void play(String program){
        if(!flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("Actor表演了" + program);
        this.notifyAll();
        this.program = program;
        this.flag = !this.flag;
    }
    public synchronized void watch(){
        if(flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("Watcher看了" + program);
        this.notifyAll();
        this.flag = !this.flag;
    }
}