JAVA进阶27（多线程/02）

1、线程同步

并发：同一个对象多个线程同步操作

package cn.Thread_demo;

/**
 * @Classname SynBlockTest01
 * @Description TODO
 * @Date 2019-5-13 12:16
 * @Created by Administrator
 */
public class SynBlockTest01 {
    public static void main(String[] args) {
        //一份资源
        SynWeb12306 web = new SynWeb12306();
        //多个代理
        new Thread(web, "张三").start();
        new Thread(web, "张四").start();
        new Thread(web, "张五").start();
    }
}

class SynWeb12306 implements Runnable {
    //票数
    private int ticketNums = 10;
    private boolean flag = true;

    @Override
    public void run() {
        while (flag) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            test2();
        }
    }
    public synchronized void test2(){
        synchronized (this){
            if (ticketNums <= 0) {
                flag = false;
                return;
            }
        }
        //模拟延时
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"--"+ticketNums--);
    }

    //线程不安全， tickNums对象在变
    public synchronized void test(){
        if (ticketNums <= 0) {
            flag = false;
            return;
        }
        //模拟延时
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"--"+ticketNums--);
    }
}

运行图

2、影院购票模拟

-----简单版

package cn.Thread_demo;

import javax.security.auth.login.AccountException;

/**
 * @Classname HappyCinema
 * @Description TODO
 * @Date 2019-5-14 10:30
 * @Created by Administrator
 * <p>
 * #####选位置
 */
public class HappyCinema {
    public static void main(String[] args) {
        Cinema c = new Cinema(2, "后天");
        new Thread(new Customer(c,4),"张三").start();
        new Thread(new Customer(c,2),"李四").start();
    }
}

//顾客
class Customer implements Runnable {
    Cinema cinema;
    int seats;

    public Customer(Cinema cinema, int seats) {
        this.cinema = cinema;
        this.seats = seats;
    }

    @Override
    public void run() {
        synchronized (cinema) {
            boolean flag = cinema.bookTickets(seats);
            if (flag) {
                System.out.println("出票成功" + Thread.currentThread().getName() + "位置为：" + seats);
            } else {
                System.out.println("出票失败" + Thread.currentThread().getName() + "位置为不够");
            }
        }
    }
}

//影院
class Cinema {
    int available;  //可供选择的位置
    String name;    //名称

    public Cinema(int available, String name) {
        this.available = available;
        this.name = name;
    }

    //购票
    public boolean bookTickets(int seats) {
        System.out.println("可用位置为：" + available);
        if (seats > available) {
            return false;
        }
        available -= seats;
        return true;
    }
}

-----加入容器版

package cn.Thread_demo;

import java.util.ArrayList;
import java.util.List;

/**
 * @Classname HappyCinema
 * @Description TODO
 * @Date 2019-5-14 10:30
 * @Created by Administrator
 * <p>
 * #####选位置
 */
public class HappyCinema01 {
    public static void main(String[] args) {
        //可用位置
        List<Integer> available = new ArrayList<>();
        available.add(1);
        available.add(2);
        available.add(4);
        available.add(5);
        available.add(7);

        //顾客需要的位置
        List<Integer> seats1 = new ArrayList<>();
        seats1.add(1);
        seats1.add(2);
        List<Integer> seats2 = new ArrayList<>();
        seats2.add(3);
        seats2.add(7);
        HtCinema c = new HtCinema(available,"HtCinema");
        new Thread(new HappyCustomer(c, seats1), "张三").start();
        new Thread(new HappyCustomer(c, seats2), "李四").start();
    }
}

//顾客
class HappyCustomer implements Runnable {
    HtCinema cinema;
    List<Integer> seats;

    public HappyCustomer(HtCinema cinema, List<Integer> seats) {
        this.cinema = cinema;
        this.seats = seats;
    }

    @Override
    public void run() {
        synchronized (cinema) {
            boolean flag = cinema.bookTickets(seats);
            if (flag) {
                System.out.println("出票成功" + Thread.currentThread().getName() + "位置为：" + seats);
            } else {
                System.out.println("出票失败" + Thread.currentThread().getName() + "位置为不够");
            }
        }
    }
}

//影院
class HtCinema {
    List<Integer> available;  //可供选择的位置
    String name;    //名称

    public HtCinema(List<Integer> available, String name) {
        this.available = available;
        this.name = name;
    }

    //购票
    public boolean bookTickets(List<Integer> seats) {
        System.out.println("可用位置为：" + available);
        List<Integer> copy = new ArrayList<>();
        copy.addAll(available);

        //相减
        copy.retainAll(seats);
        //判断大小
        if (available.size()-copy.size()!=seats.size()){
            return false;
        }
        //成功
        available = copy;
        return true;
    }
}

3、死锁

过多的同步可能造成相互不释放资源。从而相互等待，一般发生于同步中持有多个对象的锁。

4、线程协作

并发协作模型：“生产者/消费者模式”---管程法、信号灯法

生产者：负责生产数据的模块（这里的模块可能是：方法、对象、线程、进程）

消费者：负责处理数据的模块（这里的模块可能是：方法、对象、线程、进程）

缓冲区：消费者不能直接使用生产者的数据，他们之间有个“缓冲区”;生产者将生产好的数据放入“缓冲区”，消费者从“缓冲区”拿要处理的数据。

package cn.Thread_demo;

/**
 * @Classname CoTest01
 * @Description TODO
 * @Date 2019-5-15 14:16
 * @Created by Administrator
 * 协作模型：生产者消费者实现方式一：管程法
 */
public class CoTest01 {
    public static void main(String[] args) {
        SynContainer container = new SynContainer();
        new Productor(container).start();
        new Consumer(container).start();
    }
}

//生产者
class Productor extends Thread {
    SynContainer container;

    public Productor(SynContainer container) {
        this.container = container;
    }

    @Override
    public void run() {
//        生产
        for (int i = 0; i < 100; i++) {
            System.out.println("生产--" + i + "个");
            container.push(new Steamedbun(i));
        }
    }
}

//消费者
class Consumer extends Thread {
    SynContainer container;

    public Consumer(SynContainer container) {
        this.container = container;
    }

    @Override
    public void run() {
//        消费
        for (int i = 0; i < 100; i++) {
            System.out.println("消费--" + container.pop().id + "个");
            container.push(new Steamedbun(i));
        }
    }
}

//缓冲区
class SynContainer {
    Steamedbun[] buns = new Steamedbun[10];  //存储容器
    int count = 0;      //计数器

    //    存储 / 生产
    public synchronized void push(Steamedbun bun) {
//        何时能生产---  容器存在空间
//        不能生产---等待
        if (count==buns.length){
            try {
                this.wait();       //线程阻塞，消费者通知生产解除
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
//        存在空间---  可以生产
        buns[count] = bun;
        count++;
        this.notifyAll();
    }

    //    获取 / 消费
    public synchronized Steamedbun pop() {
//        何时消费，容器中是否存在数据
//        没有数据---等待
        if (count==0){
            try {
                this.wait();    //线程阻塞。生产者通知消费时解除
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
//        存在数据---可以消费
        count--;
        Steamedbun bun = buns[count];
        this.notifyAll();
        return bun;
    }
}

//数据
class Steamedbun {
    int id;

    public Steamedbun(int id) {
        this.id = id;
    }
}

package cn.Thread_demo;

/**
 * @Classname CoTest02
 * @Description TODO
 * @Date 2019-5-15 14:48
 * @Created by Administrator
 * 协作模型：生产者消费者实现方式一：信号灯法
 * 借助标志位
 */
public class CoTest02 {
    public static void main(String[] args) {
        Tv tv = new Tv();
        new Player(tv).start();
        new Watch(tv).start();
    }
}

//生产者--演员
class Player extends Thread {
    Tv tv;

    public Player(Tv tv) {
        this.tv = tv;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            if (i % 2 == 0) {
                this.tv.play("奇葩说");
            } else {
                this.tv.play("hello world");
            }
        }
    }
}

//消费者--观众
class Watch extends Thread {
    Tv tv;

    public Watch(Tv tv) {
        this.tv = tv;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            tv.watch();
        }
    }
}

//同一个资源--电视
class Tv {
    String voice;
    //信号灯
    //T 表示演员表演 观众等待
    //F 表示观众观看 演员等待
    boolean flag = true;

    //表演
    public synchronized void play(String voice) {
        //演员等待
        if (!flag) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("表演了" + voice);
        this.voice = voice;
        //唤醒
        this.notifyAll();
        this.flag = !this.flag;       //切换标志
    }

    //观看
    public synchronized void watch() {
        //观众等待
        if (flag) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //观看
        System.out.println("听到了" + voice);
        //唤醒
        this.notifyAll();
        this.flag = !this.flag;   //切换标志
    }
}

5、单例模式

package cn.Thread_demo;

/**
 * @Classname DoubleCheckedLocking
 * @Description TODO
 * @Date 2019-5-16 10:36
 * @Created by Administrator
 * ---单例模式：套路，在多线程环境下，对外存在一个对象
 * 1、构造器私有化--避免外部new构造器
 * 2、提供私有的静态属性--存储对象的地址
 * 3、提供公共的静态方法--获取属性
 */
public class DoubleCheckedLocking {
    //    1、构造器私有化
    private DoubleCheckedLocking() {

    }

    //    2、提供私有的静态属性(没有volatile，其他线程可能访问一个没有初始化的对象）
    private static volatile DoubleCheckedLocking instance;

    //    3、提供公共的静态方法
    public static DoubleCheckedLocking getInstance() {
        //再次检测
        if (null != instance) {    //避免不必要的同步，已经存在对象
            return instance;
        }
        synchronized (DoubleCheckedLocking.class) {
            if (null == instance) {
                instance = new DoubleCheckedLocking();
            }
            return instance;
        }
    }

    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            System.out.println(DoubleCheckedLocking.getInstance());
        });
        t.start();
        System.out.println(DoubleCheckedLocking.getInstance());
    }
}

运行图

6、ThreadLocal

每个线程存储自己的数据，更改不会影响其他线程

package cn.Thread_demo;

/**
 * @Classname ThreadLocalTest01
 * @Description TODO
 * @Date 2019-5-16 14:17
 * @Created by Administrator
 * ---ThreadLocal:每个线程自身的存储区域（本地、局部）
 * get/set/initialValue
 */
public class ThreadLocalTest01 {
//    private static ThreadLocal<Integer> threadLocal = new ThreadLocal<>();
//    更改初始化值
    private static ThreadLocal<Integer> threadLocal = ThreadLocal.withInitial(()->200);
    public static void main(String[] args) {
        //获取值
        System.out.println(Thread.currentThread().getName() + "-->" + threadLocal.get());
        //设置值
        threadLocal.set(199);
        System.out.println(Thread.currentThread().getName() + "-->" + threadLocal.get());
        new Thread(new MyRun()).start();
    }
    public static class MyRun implements Runnable{
        @Override
        public void run() {
            threadLocal.set((int)(Math.random()*99));
            System.out.println(Thread.currentThread().getName() + "-->" + threadLocal.get());
        }
    }
}

运行图

7、可重入锁：锁可以延续使用

package cn.Thread_demo;

/**
 * @Classname LockTest
 * @Description TODO
 * @Date 2019-5-16 15:14
 * @Created by Administrator
 *     可重入锁：锁可以延续使用
 */
public class LockTest {
    public void test(){
        //第一次获得锁
        synchronized (this){
            while (true){
                //第二次获得同样的锁
                synchronized (this){
                    System.out.println("ReentrantLock!");
                }
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public static void main(String[] args) {
        new LockTest().test();
    }
}

运行图

8、JUC