Java多线程

线程简介

1. 线程就是独立的执行路径；
2. 在程序运行时，即使自己没有创建线程，后台也会有多个线程，如主线程、gc线程；
3. main()：主线程，为系统的入口，用于执行整个程序；
4. 在一个进程中，如果开辟了多个线程，线程的运行由调度器安排调度，调度器是与操作系统紧密相关的，先后顺序不能人为干预；
5. 对同一份资源操作时，会存在资源抢夺问题，需要加入并发控制；
6. 线程会带来额外开销，如cpu调度时间、并发控制开销；
7. 每个线程在自己的工作内存交互，内存控制不当会造成数据不一致。

线程创建

三种创建方式

1. Thread class 继承Thread类
2. Runnable 接口 实现Runnable接口
3. Callable 接口 实现Callable接口（了解）

Thread

步骤

1. 自定义线程类继承Thread类；
2. 重写run()方法，编写程序执行体；
3. 创建线程对象，调用start()方法启动线程。

线程不一定立即执行，由cpu安排调度

package com.man.lesson01;

/**
 * 创建线程方式一：自定义类继承Thread类；重写run()；调用start()
 *
 * 总结：线程不一定立即执行，CPU安排调度
 */
public class ThreadTest extends Thread {//继承Thread类
    @Override
    public void run() {
        //重写run()方法
        for (int i = 0; i < 200; i++) {
            System.out.println("我正在看书---"+i);
        }

    }

    public static void main(String[] args) {
        //创建线程对象
        ThreadTest threadTest = new ThreadTest();

        //调用start方法
        threadTest.start();

        for (int i = 0; i < 2000; i++) {
            System.out.println("我正在学习多线程---"+i);
        }
    }
}

实现Runnable接口

步骤

1. 定义类实现Runnable接口；
2. 实现run()方法，编写程序执行体；
3. 创建线程对象，调用start()方法启动线程。（代理，和Thread的创建不一样）

推荐使用Runnable接口，因为Java的单继承机制

package com.man.lesson01;

/**
 * 多线程创建方法二：定义类实现Runnable接口；实现run()方法，执行线程需要丢入Runnable接口实现类；调用start()方法
 */
public class ThreadTest2 implements Runnable{
    @Override
    public void run() {
        //重写run()方法
        for (int i = 0; i < 200; i++) {
            System.out.println("我正在看书---"+i);
        }

    }

    public static void main(String[] args) {
        //创建线程对象
//        ThreadTest2 threadTest2 = new ThreadTest2();
//        Thread thread = new Thread(threadTest2);

        //调用start方法
//        thread.start();

        new Thread(new ThreadTest2()).start();//上面代码等同

        for (int i = 0; i < 2000; i++) {
            System.out.println("我正在学习多线程---"+i);
        }
    }
}

初识并发问题

多个数据操作同一个资源的情况下，线程不安全，数据紊乱。

package com.man.lesson01;

/**
 * 多个线程操作一个对象
 * 多个线程操作同一个资源的情况下，线程不安全，数据紊乱
 */
public class ThreadTest3 implements Runnable{

    private int ticketNum = 10;

    @Override
    public void run() {
        while (true){
            if (ticketNum <= 0){
                break;
            }

            //sleep模拟延网络时
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"买了第"+ticketNum--+"张票");
        }
    }

    public static void main(String[] args) {
        ThreadTest3 ticket = new ThreadTest3();

        new Thread(ticket,"小明").start();
        new Thread(ticket,"李芳").start();
        new Thread(ticket,"黄牛").start();
    }
}

实现Callable接口

步骤

1. 实现Callable接口，需要返回值类型；
2. 重写call()方法，需要抛出异常；
3. 创建目标对象；
4. 创建执行服务

ExecutorService ser = Executors.newFixedThreadPool(1);

5. 提交执行

Future<Boolean> redult1 = ser.submit(t1)

6. 获取结果

boolean r1 = result1.get();

7. 关闭服务

ser.shutdownNow();

静态代理模式

真实对象和代理对象都要实现同一个接口；

代理对象要代理真实角色。

好处：

代理对象可以做很多真实对象做不了的事情，真实对象专注于做自己的事情。

package com.man.lesson01;

/**
 * 模拟龟兔赛跑
 */
public class Race implements Runnable{
    private static String winner;

    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {

            //模拟兔子睡觉
            if (Thread.currentThread().getName().equals("兔子") && (i+1)%10==0){
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            //判断比赛是否结束
            boolean tag = gameOver(i);

            //如果比赛结束则停止
            if (tag){
                break;
            }
            System.out.println(Thread.currentThread().getName()+"跑了第"+i+"步");
        }
    }

    //判断赢家的方法
    public boolean gameOver(int step) {
        if (winner != null) {
            return true;
        } {
            if (step>=100){
                winner = Thread.currentThread().getName();
                System.out.println(winner+"胜利了");
                return true;
            }
        }
        return false;
    }

    public static void main(String[] args) {
        Race race = new Race();

        new Thread(race,"兔子").start();
        new Thread(race,"乌龟").start();
    }
}

lambda表达式

好处：避免匿名内部类定义过多。

实质是函数式编程的概念。

new Thread(()->System.out.println("...")).start();

package com.man.lesson02;

/**
 * lambda表达式
 */
public class LambdaTest {

    //2.静态内部类
    static class Like2 implements ILike{

        @Override
        public void like() {
            System.out.println("I like 2");
        }
    }

    public static void main(String[] args) {
        new Like().like();

        new Like2().like();

        //3.成员内部类
        class Like3 implements ILike{

            @Override
            public void like() {
                System.out.println("I like 3");
            }
        }

        new Like3().like();

        //4.匿名内部类
        ILike like4 = new ILike() {
            @Override
            public void like() {
                System.out.println("I like 4");
            }
        };
        like4.like();

        //5.lambda表达式
        ILike like5 = ()->{
            System.out.println("I like 5");
        };
        like5.like();
    }
}

//定义一个函数式接口
interface ILike{
    void like();
}

//1.实现类
class Like implements ILike{
    @Override
    public void like() {
        System.out.println("I like 1");
    }
}

package com.man.lesson02;

/**
 * 带有参数的lambda表达式
 */
public class LambdaTest2 {
    public static void main(String[] args) {
        ILove love = (int a)->{
            System.out.println("I love "+a);
        };
        love.love(1);

        //省去参数类型,多个参数时也可以省略，要省略都一起省略
        ILove love2 = (a)->{
            System.out.println("I love "+a);
        };
        love.love(2);

        //省去括号
        ILove love3 = a->{
            System.out.println("I love "+a);
        };
        love.love(3);

        //省去大括号,只有一行语句可以省略大括号
        ILove love4 = a-> System.out.println("I love "+a);;
        love.love(4);

    }
}

interface ILove{
    void love(int a);
}

函数式接口

任何只包含唯一一个抽象方法的接口

对于函数式接口，可以通过lambda表达式来创建该接口的对象。

线程状态

五大状态

• 创建状态（new）

• 就绪状态（start()）

• 阻塞状态（调用sleep()、wait()或同步锁定）

• 运行状态

• 死亡状态

线程方法

• setPriority(int newPriority) 更改线程的优先级
• static void sleep(long mills) 在指定的毫秒数内让当前正在执行的线程休眠
• void join() 等待该线程终止
• static void yield() 暂停当前的，执行其他的
• void interrupt()中断，不建议使用
• boolean isAlive() 测试线程是否处于活动状态

停止线程

1. 不推荐使用JDK提供的stop()、destroy()
2. 推荐让其自己停下来
3. 建议使用一个标志位

package com.man.state;

/**
 * 线程状态-->线程停止
 * 1.建议线程正常停止-->利用次数，不建议死循环
 * 2.建议使用标志位-->设置一个标志位
 * 3.不建议使用已过时的stop和destroy或者JDK不建议的方法
 */
public class StopTest implements Runnable{
    //设置一个标志位
    private boolean tag = true;

    @Override
    public void run() {
        int i = 0;
        while (tag) {
            System.out.println("Run------Thread"+i);
        }
    }

    //设置一个公共的方法停止线程，改变标志位
    public void stop(){
        this.tag = false;
    }

    public static void main(String[] args) {
        StopTest stopTest = new StopTest();

        new Thread(stopTest).start();

        for (int i = 0; i < 1000; i++) {
            if (i==900) {
                stopTest.stop();
                System.out.println("Thread已停止");
            }
            System.out.println("main"+i);
        }
    }
}

线程休眠

1. sleep(时间) 指定当前线程阻塞的毫秒数
2. sleep存在InterruptedException
3. sleep时间达到后，线程进入就绪状态
4. sleep可以模拟网络延时、倒计时等
5. 每一个对象都有一个锁，sleep不会释放锁（sleep可以放大问题的发生性）

package com.man.state;

/**
 * 模拟倒计时
 */
public class SleepTest {
    public static void main(String[] args) throws InterruptedException {
        tenDown();
    }

    public static void tenDown() throws InterruptedException {
        int num = 10;

        while (true){
            System.out.println(num--);
            Thread.sleep(1000);
            if (num<=0){
                break;
            }
        }
    }
}

package com.man.state;

import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * 打印时间
 */
public class SleepTest2 {
    public static void main(String[] args) {
        try {
            back();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void back() throws InterruptedException {
        Date date = new Date(System.currentTimeMillis());

        int i = 0;

        while (true){
            SimpleDateFormat simpleDateFormat = new SimpleDateFormat("HH:mm:ss");

            System.out.println(simpleDateFormat.format(date));

            Thread.sleep(1000);

            date = new Date(System.currentTimeMillis());

            if (i++>=10){
                break;
            }
        }
    }
}

线程礼让——yield()

1. 礼让线程：让当前正在执行的线程暂停，但不阻塞；
2. 将线程从运行状态转为就绪状态；
3. 让cpu重新调度，礼让不一定成功，看cpu心情。

package com.man.state;

/**
 * 线程礼让
 * 礼让不一定成功，看CPU心情！！！
 */
public class YieldTest {
    public static void main(String[] args) {
        MyYield myYield = new MyYield();

        new Thread(myYield,"a").start();
        new Thread(myYield,"b").start();
    }
}

class MyYield implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"线程开始");
        Thread.yield();
        System.out.println(Thread.currentThread().getName()+"线程结束");
    }
}

线程强制执行——join()

1. join合并线程，待此线程执行完，再执行其他线程；
2. 可以想象为插队。

package com.man.state;

/**
 * 线程强制执行
 * join合并线程，待此线程执行结束后，再执行其他线程
 * 可以想象为插队
 */
public class JoinTest {
    public static void main(String[] args) throws InterruptedException {
        MyJoin myJoin = new MyJoin();
        Thread thread = new Thread(myJoin);
        thread.start();

        //主线程
        for (int i = 0; i < 1000; i++) {
            if (i==100){
                thread.join();
            }
            System.out.println("main-->"+i);
        }
    }
}

class MyJoin implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("Thread-->"+i);
        }
    }
}

观测线程状态

Thread.State

1. NEW
2. RUNNABLE
3. BLOCKED 被阻塞
4. WAITING
5. TIMED_WAITING
6. TERMINATED

package com.man.state;

public class StateTest {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(()->{
            for (int i = 0; i < 5; i++) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("==============");
        });

        Thread.State state = thread.getState();
        System.out.println(state);//new

        //启动后
        thread.start();
        state = thread.getState();
        System.out.println(state);

        while (state!=Thread.State.TERMINATED) {//只要线程不停止
            Thread.sleep(100);
            state = thread.getState();
            System.out.println(state);
        }
    }
}

线程的优先级

Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度器按照优先级决定应调度哪个线程来执行

线程的优先级用数字表示（范围从1-10）

Thread.MIN_PRIORITY = 1

Thread.MAX_PRIORITY = 10

Thread.NORM_PRIORITY = 5

优先级低只是意味着获得调度的概率低，并不是优先级低就不会被调用了（看cpu心情）

getPriority() 获取优先级

setPriority() 改变优先级

主线程优先级默认

package com.man.state;

/**
 * 线程的优先级
 * 范围从1-10
 *
 * 优先级低只是意味着获得调度的概率低
 */
public class PriorityTest {
    public static void main(String[] args) {
        //主线程的优先级
        System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());

        MyPriority myPriority = new MyPriority();

        Thread t1 = new Thread(myPriority,"t1");
        Thread t2 = new Thread(myPriority,"t2");
        Thread t3 = new Thread(myPriority,"t3");
        Thread t4 = new Thread(myPriority,"t4");
        Thread t5 = new Thread(myPriority,"t5");

        t1.setPriority(9);
        t1.start();

        t2.start();

        t3.setPriority(Thread.MAX_PRIORITY);
        t3.start();

        t4.start();

        t5.setPriority(7);
        t5.start();
    }
}

class MyPriority implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());
    }
}

守护（daemon）线程

线程分为用户线程和守护线程

虚拟机必须确保用户线程执行完毕

虚拟机不用等待守护线程执行完毕

如：后台记录操作日志、监控日志、垃圾回收等待

package com.man.state;

/**
 * 守护线程
 * 虚拟机必须等待用户线程执行完毕，不必等待守护线程执行完毕
 * 模拟：上帝保佑你直到离世
 */
public class DaemonTest {
    public static void main(String[] args) {
        God god = new God();
        You you = new You();

        Thread thread = new Thread(god);
        thread.setDaemon(true);//默认是false为用户线程，true为守护线程
        thread.start();

        new Thread(you).start();
    }
}

class God implements Runnable{
    @Override
    public void run() {
        while (true){
            System.out.println("上帝保佑你");
        }
    }
}

class You implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 36500; i++) {
            System.out.println("=====开心地活着=====");
        }
        System.out.println("Goodbye,world!");
    }
}

线程同步

线程同步机制

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

线程同步synchronized

其实就是等待机制，多个需要同时访问此对象的线程进入这个对象的等待池形成队列，等待前面线程使用完毕后，下一个线程再使用，可以想象成排队

形成条件：队列+锁（解决线程不安全）

但存在以下问题：

• 引起性能问题；
• 优先级倒置；
• 一个线程持有锁会导致其他所有需要此锁的线程挂起。

同步方法和同步块

关键字：synchronized

包含同步方法和同步块两种方法

synchronized方法

控制对“对象”的访问，每个对象对应一把锁，synchronized方法必须通过获得调用该方法的对象的锁才能执行，否则线程会阻塞，方法一旦执行就独占该锁，直到该方法返回才释放锁，后面被阻塞的线程才能获得这个锁，继续执行。

缺陷：若将一个大的方法申明为synchronized将会影响效率；

弊端：方法里面需要修改的内容才需要锁，锁的太多浪费资源。

同步块

synchronized(obj){}

obj:同步监视器

1. obj可以是任何对象，但推荐使用共享资源作为同步监视器；
2. 同步方法中无需指定同步监视器，因为同步方法的同步监视器就是this,即该对象本身或class

CopyOnWriteArrayList

线程安全的一个集合 juc中（java.util.concurrent）

死锁

1. 某一个同步块同时拥有“两个以上对象的锁”时，就可能发生“死锁”的问题；
2. 避免方式，从必要条件中避免

package com.man.syn;

/**
 * 死锁：多个线程互相抱着对象所需要的资源，形成僵持
 */
public class DeadTest {
    public static void main(String[] args) {
        MakeUp g1 = new MakeUp(0,"灰姑娘");
        MakeUp g2 = new MakeUp(1,"白雪公主");

        g1.start();
        g2.start();
    }
}

//口红
class LipStick{}

//镜子
class Mirror{}

//化妆
class MakeUp extends Thread{
    //需要的资源只有一份，用static控制
    static LipStick lipStick = new LipStick();
    static Mirror mirror = new Mirror();

    int choice;//0表示口红
    String girlName;

    public MakeUp(int choice,String girlName){
        this.choice = choice;
        this.girlName = girlName;
    }

    @Override
    public void run() {
        //化妆
        try {
            makeup();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    private void makeup() throws InterruptedException {
        if (choice == 0) {
            synchronized (lipStick) {
                //获得口红的锁
                System.out.println(this.girlName + "获得口红的锁");
                Thread.sleep(1000);
                synchronized (mirror) {
                    //一秒钟后想获得镜子
                    System.out.println(this.girlName + "获得镜子的锁");
                }
            }
        } else {
            synchronized (mirror) {
                //获得口红的锁
                System.out.println(this.girlName + "获得镜子的锁");
                Thread.sleep(2000);
                synchronized (lipStick) {
                    //一秒钟后想获得镜子
                    System.out.println(this.girlName + "获得口红的锁");
                }
            }
        }
    }
}

产生死锁的四个必要条件：

• 互斥条件：一个资源每次只能被一个进程使用；
• 请求与保持条件：一个进程因请求资源而被阻塞时，对已获得的资源保持不放；
• 不剥夺条件：进程已获得的资源，在未使用完之前，不能强行剥夺；
• 循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系

我们只要想办法破坏其中任意一个或多个就可以避免死锁发生

package com.man.syn;

/**
 * 死锁：多个线程互相抱着对象所需要的资源，形成僵持
 */
public class DeadTest2 {
    public static void main(String[] args) {
        MakeUp2 g1 = new MakeUp2(0,"灰姑娘");
        MakeUp2 g2 = new MakeUp2(1,"白雪公主");

        g1.start();
        g2.start();
    }
}

//口红
class LipStick2{}

//镜子
class Mirror2{}

//化妆
class MakeUp2 extends Thread{
    //需要的资源只有一份，用static控制
    static LipStick lipStick = new LipStick();
    static Mirror mirror = new Mirror();

    int choice;//0表示口红
    String girlName;

    public MakeUp2(int choice,String girlName){
        this.choice = choice;
        this.girlName = girlName;
    }

    @Override
    public void run() {
        //化妆
        try {
            makeup();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    private void makeup() throws InterruptedException {
        if (choice == 0) {
            synchronized (lipStick) {
                //获得口红的锁
                System.out.println(this.girlName + "获得口红的锁");
                Thread.sleep(1000);
            }
            synchronized (mirror) {
                //一秒钟后想获得镜子
                System.out.println(this.girlName + "获得镜子的锁");
            }
        } else {
            synchronized (mirror) {
                //获得口红的锁
                System.out.println(this.girlName + "获得镜子的锁");
                Thread.sleep(2000);
            }
            synchronized (lipStick) {
                //一秒钟后想获得镜子
                System.out.println(this.girlName + "获得口红的锁");
            }
        }
    }
}

Lock锁

1. 显示定义同步锁来实现同步

常用的ReentrantLock类实现java.util.concurrent.locks.Lock接口，可以显示加锁，释放锁

class A{
    private final ReentrantLock lock = new ReentrantLock();
    
    public void m(){
        lock.lock();
        try{
            //保证线程安全的代码
        }
        finally{
            lock.unlock();
            //如果要同步的代码有异常处理，就将unlock()写在finally块
        }
    }
}

3. synchronized与Lock对比

• Lock显式 synchronized隐式
• Lock只有代码块锁，synchronized有方法锁
• 使用Lock锁，性能更好，有更好的扩展性，优先使用顺序

Lock > 同步代码块 > 同步方法

package com.man.syn;

import java.util.concurrent.locks.ReentrantLock;

/**
 * 测试Lock锁
 */
public class LockTest {
    public static void main(String[] args) {
        Lock2 lock2 = new Lock2();

        new Thread(lock2).start();
        new Thread(lock2).start();
        new Thread(lock2).start();
    }
}

class Lock2 implements Runnable{

    int num = 10;

    //定义Lock锁
    private final ReentrantLock reentrantLock = new ReentrantLock();

    @Override
    public void run() {
        while (true){
            try {
                reentrantLock.lock();//加锁
                if (num>0){
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(num--);
                }
                else {
                    break;
                }
            }finally {
                reentrantLock.unlock();//解锁
            }
        }
    }
}

不安全的案例

案例一

package com.man.syn;

/**
 * 线程不安全---取钱
 */
public class UnsafeBank {
    public static void main(String[] args) {
        Account account = new Account(1000,"基金");

        Bank bank = new Bank(account,50,"I");
        bank.start();

        Bank bank1 = new Bank(account,100,"You");

        bank1.start();
    }
}

class Account{
    int money;//账户的钱
    String name;//账号名字

    public Account(int money, String name) {
        this.money = money;
        this.name = name;
    }
}

class Bank extends Thread{
    Account account;//取钱的账号
    int drawingMoney;//取的金额
    int nowMoney;//手里的钱

    public Bank(Account account,int drawingMoney,String name){
        super(name);

        this.account = account;
        this.drawingMoney = drawingMoney;
    }

    @Override
    public void run() {
        synchronized (account){
            if (account.money-drawingMoney<=0){
                System.out.println("余额不足");
                return;
            }

            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            account.money -= drawingMoney;
            nowMoney += drawingMoney;
            System.out.println(account.name+"卡里的余额"+account.money);
            System.out.println(Thread.currentThread().getName()+"手里的钱"+nowMoney);
        }
        }
}

案例二：

package com.man.syn;

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

/**
 * ArrayList集合是线程不安全的
 */
public class UnsafeList {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        for (int i = 0; i < 5000; i++) {
            new Thread(()->{
                synchronized (list){//没成功？？？
                    list.add(Thread.currentThread().getName());
                }
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }).start();
        }
        System.out.println(list.size());
    }
}

案例三：

package com.man.syn;

/**
 * 线程不安全---买票
 */
public class UnsafeTicket {
    public static void main(String[] args) {
        BuyTicket buyTicket = new BuyTicket();

        new Thread(buyTicket,"小明").start();
        new Thread(buyTicket,"小红").start();
        new Thread(buyTicket,"黄牛").start();
    }
}

class BuyTicket implements Runnable{
    private int ticketNum = 10;
    boolean tag = true;

    @Override
    public void run() {
        try {
            buy();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    //买票
    public synchronized void buy() throws InterruptedException {
        while (tag){
            System.out.println(Thread.currentThread().getName()+"买到了第"+ticketNum--+"张票");

            Thread.sleep(100);

            if (ticketNum<=0){
                this.tag = false;
                System.out.println("票卖完了");
            }
        }
    }
}

线程协作

生产者消费者问题

线程通信

• wait() 表示让线程等待，与sleep()不同，会释放锁；
• wait(long timeout)
• notify() 唤醒一个等待的线程
• notifyAll()

均是Object类的方法，都只能在同步方法或同步代码块中使用

解决办法

1. 并发协作模型“生产者/消费者”——管程法

生产者：负责生产数据的模块；

消费者：负责处理数据的模块；

缓冲区：消费者不能直接使用生产者的数据，他们之间有个“缓冲区”。

生产者将生产好的数据放入缓冲区，消费者从缓冲区拿出数据。

package com.man.last;

public class Test1 {
    public static void main(String[] args) {
        synContainer synContainer = new synContainer();

        new Producer(synContainer).start();
        new Costumer(synContainer).start();
    }
}

//生产者
class Producer extends Thread{
    synContainer container;

    public Producer(synContainer container){
        this.container = container;
    }

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

//消费者
class Costumer extends Thread{
    synContainer container;

    public Costumer(synContainer container){
        this.container = container;
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("消费了第"+container.pop().id+"个产品");
        }
    }
}

//产品
class Product{
    int id;

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

//缓冲区
class synContainer{
    //需要一个容器大小
    Product[] products = new Product[10];
    //容器计数器
    int count = 0;

    //生产者放入产品
    public synchronized void push(Product product){
        //判断容器是否满了，满了生产者要等待
        if (count==products.length){
            //通知消费者消费，生产者等待

            //生产等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        //如果没有满，就放入产品
        products[count]=product;
        count++;

        //可以通知消费者消费
        this.notifyAll();
    }

    //消费者拿走产品
    public synchronized Product pop(){
        //判断是否可以消费
        if (count==0){
            //生产者生产，消费者等待

            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        //如果可以消费
        count--;
        Product product = products[count];

        //吃过了，通知生产者生产
        this.notifyAll();

        return product;
    }
}

2. 并发协作模型“生产者/消费者模式”——信号灯法

设一个标志位

package com.man.last;

/**
 * 测试生产者消费者问题2---信号灯法 设置一个标志位
 */
public class Test2 {
    public static void main(String[] args) {
        TV tv = new TV();

        new Player(tv).start();
        new Audience(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){
                tv.play("快乐大本营");
            }else {
                tv.play("萌探探探案");
            }
        }
    }
}

//观众
class Audience extends Thread{
    TV tv;
    public Audience(TV tv){
        this.tv = tv;
    }

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

//节目
class TV{
    String voice;
    boolean flag = true;

    //表演
    public synchronized void play(String voice){
        if (!flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("演员表演了"+voice);

        //通知观众观看
        this.notifyAll();
        this.voice = voice;
        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;
    }
}

线程池

1. 思路

提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中，可实现重复利用，类似于生活中的公共交通工具

package com.man.last;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * 线程池
 */
public class PoolTest {
    public static void main(String[] args) {
        //1.创建服务，创建线程池
        //参数是线程池大小
        ExecutorService service = Executors.newFixedThreadPool(10);

        //执行
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());

        //2.关闭连接
        service.shutdown();
    }
}

class MyThread implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}

2. 好处

• 提高响应速度；
• 降低资源消耗；
• 便于线程管理

corePoolSize:核心池大小；

maximumPoolSize:最大线程数；

keepAliveTime:线程没有任务时最多保持多长时间后终止。