多线程学习笔记

笔记地址

1.继承Thread

//练习，多线程同步下载图片
public class ThreadTest2 extends Thread {

    private String url;//图片下载的地址
    private String name;//保存的文件名

    public ThreadTest2( String url, String name) {
        this.url = url;
        this.name = name;
    }

    //下载图片的执行体
    @Override
    public void run() {
        WebDownLoader webDownLoader = new WebDownLoader();
        webDownLoader.downloader(url,name);
        System.out.println("下载了图片名为"+name);
    }

    public static void main(String[] args) {
        ThreadTest2 t1 = new ThreadTest2("https://www.baidu.com/img/PCtm_d9c8750bed0b3c7d089fa7d55720d6cf.png","1.jpg");
        ThreadTest2 t2 = new ThreadTest2("https://www.baidu.com/img/PCtm_d9c8750bed0b3c7d089fa7d55720d6cf.png","2.jpg");
        ThreadTest2 t3 = new ThreadTest2("https://www.baidu.com/img/PCtm_d9c8750bed0b3c7d089fa7d55720d6cf.png","3.jpg");
        t1.start();
        t2.start();
        t3.start();
    }
}
//下载器
class WebDownLoader{
    //下载方法
   public void downloader(String url,String name){
       try {
           //url变成文件
           FileUtils.copyURLToFile(new URL(url),new File(name));
       } catch (IOException e) {
           e.printStackTrace();
           System.out.println("IO异常，downloader方法出现问题");
       }
   }
}

2.实现Runnable接口

/**
 * 多个线程同时操作同一个的对象
 * 买火车票
 * 线程不安全，数据混乱
 */
public class ThreadTest4 implements Runnable {

    private int ticketNums = 10;

    @Override
    public void run() {
        while (true){
            if (ticketNums <= 0){
                break;
            }
            try {
                //模拟延时
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //拿到线程名字
            System.out.println(Thread.currentThread().getName() + "--->拿到了第" + ticketNums-- + "张票");
        }
    }

    public static void main(String[] args) {
        ThreadTest4 threadTest4 = new ThreadTest4();
        new Thread(threadTest4,"小明").start();
        new Thread(threadTest4,"老师").start();
        new Thread(threadTest4,"黄牛").start();
    }
}

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

    @Override
    public void run() {
        for (int i = 1; i <= 100; i++) {
            //模拟兔子睡觉
            if (Thread.currentThread().getName().equals("兔子") && i%30==0){
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            //判断比赛是否结束
            boolean flag = gameover(i);
            //如果比赛结束，停止程序
            if (flag){
                break;
            }
            System.out.println(Thread.currentThread().getName()+"-->跑了"+i+"步");
        }
    }

    //判断是否完成比赛
    private boolean gameover(int stops){
        //判断是否有胜利者
        if (winner != null){
            return true;
        }else {
            if (stops >= 100){
                winner = Thread.currentThread().getName();
                System.out.println("winner is "+winner);
                return true;
            }
        }
        return false;
    }

    //主程序
    public static void main(String[] args) {
        Race race = new Race();
        new Thread(race,"兔子").start();
        new Thread(race,"乌龟").start();
    }
}

3.实现Callable接口

//线程创建方式三：实现Callable接口
//好处：1.可以定义返回值 2.可以抛出异常
public class ThreadTest5 implements Callable<Boolean> {

    private String url;//图片下载的地址
    private String name;//保存的文件名

    public ThreadTest5( String url, String name) {
        this.url = url;
        this.name = name;
    }

    //下载图片的执行体
    @Override
    public Boolean call() {
        WebDownLoader2 webDownLoader2 = new WebDownLoader2();
        WebDownLoader2.downloader(url,name);
        System.out.println("下载了图片名为"+name);
        return true;
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ThreadTest5 t1 = new ThreadTest5("https://www.baidu.com/img/PCtm_d9c8750bed0b3c7d089fa7d55720d6cf.png","1.jpg");
        ThreadTest5 t2 = new ThreadTest5("https://www.baidu.com/img/PCtm_d9c8750bed0b3c7d089fa7d55720d6cf.png","2.jpg");
        ThreadTest5 t3 = new ThreadTest5("https://www.baidu.com/img/PCtm_d9c8750bed0b3c7d089fa7d55720d6cf.png","3.jpg");
        //创建执行服务：线程池
        ExecutorService ser = Executors.newFixedThreadPool(3);
        //提交执行，后运行
        Future<Boolean> r1 = ser.submit(t1);
        Future<Boolean> r2 = ser.submit(t2);
        Future<Boolean> r3 = ser.submit(t3);
        //获取运行结果
        boolean rs1 = r1.get();
        boolean rs2 = r2.get();
        boolean rs3 = r3.get();

        System.out.println(rs1);
        System.out.println(rs2);
        System.out.println(rs3);
        //关闭服务
        ser.shutdownNow();
    }
}
//下载器
class WebDownLoader2{
    //下载方法
    public static void downloader(String url, String name){
        try {
            //url变成文件
            FileUtils.copyURLToFile(new URL(url),new File(name));
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("IO异常，downloader方法出现问题");
        }
    }
}

4.Lamda表达式

/**
 * 推导Lambda表达式
 */
public class LambdaTest {
    //3.静态内部类
    static class Like2 implements ILike{
        @Override
        public void lambda() {
            System.out.println("I like Lambda2");
        }
    }

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

        like = new Like2();
        like.lambda();

        //4.局部内部类
        class Like3 implements ILike{
            @Override
            public void lambda() {
                System.out.println("I like Lambda3");
            }
        }
        like = new Like3();
        like.lambda();

        //5.匿名内部类，没有类的名称，必须借助接口或者父类
        like = new ILike() {
            @Override
            public void lambda() {
                System.out.println("I like Lambda4");
            }
        };
        like.lambda();

        //6.用Lambda简化
        like = ()->{
            System.out.println("I like Lambda5");
        };
        like.lambda();

    }
}

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

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

/**
 * 总结：
 *  3.Lambda表达式只能有一行代码的情况下才能简化成为一行，如果有多行，那么就用代码块包裹
 *  2.前提是接口为函数式接口（只包含唯一一个抽象方法）
 *  1.多个参数也可以去多参数类型，要去掉就都去掉，必须加上括号
 */
public class LambdaTest2 {
    public static void main(String[] args) {
        //Lambda表达式
        ILove love = (int a)->{
            System.out.println("I Love1 "+a);
        };

        //1.简化去掉参数类型
        love = (a)->{
            System.out.println("I Love2 "+a);
        };

        //2.简化参数括号
        love = a->{
            System.out.println("I Love3 "+a);
            System.out.println("I Love33 "+a);
        };

        //3.简化花括号
        love = a-> System.out.println("I Love4 "+a);

        love.love(521);
    }
}

interface ILove{
    void love(int a);
}

5.静态代理模式

/**
 * 静态代理模式
 * 真实对象和代理对象都要实现同一个接口
 * 代理对象要代理真实角色
 * 好处：代理对象可以做很多真实对象做不了的事情，真实对象专注做自己的事情
 */
public class StacticProxy {

    public static void main(String[] args) {
        Person person = new Person();

//        WeddingCompany company = new WeddingCompany(person);
//        company.HappyMarry();

        new WeddingCompany(new Person()).HappyMarry();

        new Thread(()-> System.out.println("我爱你")).start();
    }

}

//结婚
interface Marry{
    void HappyMarry();
}

//真实角色，去结婚
class Person implements Marry{
    @Override
    public void HappyMarry() {
        System.out.println("结婚开心");
    }
}
//代理角色，婚庆公司
class WeddingCompany implements Marry{

    private Marry target;
    //真实角色=>代理对象
    public WeddingCompany(Marry target) {
        this.target = target;
    }

    @Override
    public void HappyMarry() {
        before();
        this.target.HappyMarry();//真实角色
        after();
    }

    private void before() {
        System.out.println("结婚之前，布置场地");
    }

    private void after() {
        System.out.println("结婚之后，收尾款");
    }
}

6.线程状态

public class StopTest implements Runnable {
    //设置一个标识位
    private boolean flag = true;

    @Override
    public void run() {
        int i = 0;
        while (flag){
            System.out.println("run....."+i++);
        }
    }
    //设置一个方法停止线程，转换标识位
    public void stop(){
        this.flag = false;
    }

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

        for (int i = 0; i < 1000; i++) {
            System.out.println("main"+i);
            if (i == 900){
                //调用stop方法，停止线程
                stopTest.stop();
                System.out.println("线程该停止了");
            }
        }
    }
}

7.线程休眠

//模拟网络延时，放大问题的发生性
public class SleepTest implements Runnable{
    //票数
    private int ticketNums = 10;

    @Override
    public void run() {
        while (true){
            if (ticketNums <= 0){
                break;
            }
            try {
                //模拟延时
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //拿到线程名字
            System.out.println(Thread.currentThread().getName() + "--->拿到了第" + ticketNums-- + "张票");
        }
    }

    public static void main(String[] args) {
        SleepTest SleepTest = new SleepTest();
        new Thread(SleepTest,"小明").start();
        new Thread(SleepTest,"老师").start();
        new Thread(SleepTest,"黄牛").start();
    }
}

//模拟倒计时
public class SleepTest2 {
    //模拟倒计时
    public static void tenDown() throws InterruptedException {
        int num = 10;
        while (true){
            Thread.sleep(1000);
            System.out.println(num--);
            if (num < 0){
                break;
            }
        }
    }

    public static void main(String[] args) {
        //打印当前时间
        Date startTime = new Date(System.currentTimeMillis());//获取系统当前时间
        while (true){
            try {
                Thread.sleep(1000);
                System.out.println(new SimpleDateFormat("HH:mm:ss").format(startTime));
                startTime = new Date(System.currentTimeMillis());//更新当前时间
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
//        try {
//            tenDown();
//        } catch (InterruptedException e) {
//            e.printStackTrace();
//        }
    }
}

8.线程礼让

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()+"线程结束");
    }
}

9.线程强制执行

//测试join方法，插队
public class JoinTest implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i <= 50; i++) {
            System.out.println("线程vip..."+i);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        JoinTest joinTest = new JoinTest();
        Thread thread = new Thread(joinTest);
        thread.start();

        for (int i = 0; i <= 50; i++) {
            if (i == 30){
                thread.join();//插队
            }
            System.out.println("main"+i);
        }
    }
}

10.线程状态观测

//观察线程的状态
public class StateTest {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(()->{
            for (int i = 0; i < 2; 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();//RUN

        //只要线程不终止，就一直输出
        while (state != Thread.State.TERMINATED){
            Thread.sleep(100);
            state = thread.getState();//更新线程状态
            System.out.println(state);
        }
    }
}

11.线程的优先级

//测试线程的优先级
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);
        Thread t2 = new Thread(myPriority);
        Thread t3 = new Thread(myPriority);
        Thread t4 = new Thread(myPriority);
        Thread t5 = new Thread(myPriority);
        Thread t6 = new Thread(myPriority);

        //设置优先级，再启动
        t1.start();

        t2.setPriority(Thread.MIN_PRIORITY);//1
        t2.start();

        t3.setPriority(4);
        t3.start();

        t4.setPriority(Thread.MAX_PRIORITY);//10
        t4.start();

        t5.setPriority(-1);//超范围了
        t5.start();

        t6.setPriority(11);//超范围了
        t6.start();
    }
}

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

12.守护线程

//守护线程
public class DaemanTest {
    public static void main(String[] args) {
        God god = new God();
        Person person = new Person();

        Thread thread = new Thread(god);
        //默认是false表示用户线程，正常线程都是用户线程
        thread.setDaemon(true);
        //神护线程启动
        thread.start();
        //用户线程启动
        new Thread(person).start();
    }
}

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

//人
class Person implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 36500; i++) {
            System.out.println("一生都开心地活着"+i);
        }
        System.out.println("====goodbye!====");
    }
}

13.线程同步

不安全案例

/**
 * 1.不安全的买票
 * 线程不安全：有负数和重复票
 */
public class BuyTicket {
    public static void main(String[] args) {
        Ticket ticket = new Ticket();

        new Thread(ticket,"张三").start();
        new Thread(ticket,"李四").start();
        new Thread(ticket,"黄牛").start();
    }
}

class Ticket implements Runnable{
    //票
    private int ticketNums = 10;
    //外部停止方式
    boolean flag = true;

    @Override
    public void run() {
        //买票
        while (flag){
            try {
                buy();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    private void buy() throws InterruptedException {
        //判断是否有票
        if (ticketNums <= 0){
            flag = false;
            return;
        }
        //模拟延时
        Thread.sleep(10);
        //买票
        System.out.println(Thread.currentThread().getName()+"拿到"+ticketNums--);
    }
}

/**
 * 2.不安全取钱
 */
public class UnSafeBank {
    public static void main(String[] args) {
        //账户
        Account account = new Account(100,"结婚基金");

        Drawing boy = new Drawing(account,50,"男孩");
        Drawing girl = new Drawing(account,100,"女孩");

        boy.start();
        girl.start();
    }
}
//账户
class Account{
    int money;//金额
    String name;//卡名

    public Account(int money, String name) {
        this.money = money;
        this.name = name;
    }
}
//银行
class Drawing extends Thread{
    //账户
    Account account;
    //取了多少钱
    int drawingMoney;
    //现在手里有多少钱
    int nowMoney;

    public Drawing(Account account, int drawingMoney, String name) {
        super(name);
        this.account = account;
        this.drawingMoney = drawingMoney;
    }

    //取钱
    @Override
    public void run() {
        //判断有没有钱
        if (account.money - drawingMoney < 0){
            System.out.println(Thread.currentThread().getName()+"钱不够，取不了");
            return;
        }
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //卡内余额 = 余额 - 取的钱
        account.money = account.money - drawingMoney;
        //手里的钱
        nowMoney += drawingMoney;

        System.out.println(account.name+"余额为："+account.money);
        //Thread.currentThread().getName() = this..getName()
        System.out.println(this.getName()+"手里的钱"+nowMoney);
    }
}

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

同步方法和同步块

/**
 * 1.修改后，安全的买票
 */
public class BuyTicket {
    public static void main(String[] args) {
        Ticket ticket = new Ticket();

        new Thread(ticket,"张三").start();
        new Thread(ticket,"李四").start();
        new Thread(ticket,"黄牛").start();
    }
}

class Ticket implements Runnable{
    //票
    private int ticketNums = 10;
    //外部停止方式
    boolean flag = true;

    @Override
    public void run() {
        //买票
        while (flag){
            try {
                buy();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    //synchronized 同步方法，锁的是this
    private synchronized void buy() throws InterruptedException {
        //判断是否有票
        if (ticketNums <= 0){
            flag = false;
            return;
        }
        //模拟延时
        Thread.sleep(10);
        //买票
        System.out.println(Thread.currentThread().getName()+"拿到"+ticketNums--);
    }
}

/**
 * 2.修改后，安全的取钱
 */
public class UnSafeBank {
    public static void main(String[] args) {
        //账户
        Account account = new Account(100,"结婚基金");

        Drawing boy = new Drawing(account,50,"男孩");
        Drawing girl = new Drawing(account,100,"女孩");

        boy.start();
        girl.start();
    }
}
//账户
class Account{
    int money;//金额
    String name;//卡名

    public Account(int money, String name) {
        this.money = money;
        this.name = name;
    }
}
//银行
class Drawing extends Thread{
    //账户
    Account account;
    //取了多少钱
    int drawingMoney;
    //现在手里有多少钱
    int nowMoney;

    public Drawing(Account account, int drawingMoney, String name) {
        super(name);
        this.account = account;
        this.drawingMoney = drawingMoney;
    }

    //取钱
    //synchronized 默认锁的是this
    @Override
    public void run() {
        //锁的对象就是变化的量，需要增删改查的量
        synchronized (account){
            //判断有没有钱
            if (account.money - drawingMoney < 0){
                System.out.println(Thread.currentThread().getName()+"钱不够，取不了");
                return;
            }
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //卡内余额 = 余额 - 取的钱
            account.money = account.money - drawingMoney;
            //手里的钱
            nowMoney += drawingMoney;

            System.out.println(account.name+"余额为："+account.money);
            //Thread.currentThread().getName() = this..getName()
            System.out.println(this.getName()+"手里的钱"+nowMoney);
        }
    }
}

/**
 * 3.修改后，安全的集合
 */
public class UnSafeList {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        for (int i = 0; i < 10000; i++) {
            new Thread(()->{
                synchronized (list){
                    list.add(Thread.currentThread().getName());
                }
            }).start();
        }
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(list.size());
    }
}

CopyOnWriteArrayList

/**
 * JUC安全类型的集合
 */
public class JUCTest {
    public static void main(String[] args) {
        CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<String>();
        for (int i = 0; i < 10000; i++) {
            new Thread(()->{
                list.add(Thread.currentThread().getName());
            }).start();
        }
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(list.size());
    }
}

14.死锁

/**
 * 死锁：多个线程互相抱着对方需要的资源，然后形成僵持
 */
public class DeadLock {
    public static void main(String[] args) {
        Makeup m1 = new Makeup(0,"张三");
        Makeup m2 = new Makeup(1,"李四");

        m1.start();
        m2.start();
    }
}
//镜子
class Mirror{
}
//口红
class Lipstick{
}

class Makeup extends Thread{
    static Lipstick lipstick = new Lipstick();
    static Mirror mirror = new Mirror();
    //选择
    int choice;
    //使用化妆品的人
    String name;

    public Makeup(int choice, String name) {
        this.choice = choice;
        this.name = name;
    }

    @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.name+"获得口红的锁");
                Thread.sleep(1000);
                synchronized (mirror){
                    System.out.println(this.name+"获得镜子的锁");
                }
            }
        }else {
            synchronized (mirror){
                System.out.println(this.name+"获得镜子的锁"");
                Thread.sleep(1000);
                synchronized (lipstick){
                    System.out.println(this.name+"获得口红的锁");
                }
            }
        }
    }
}

修改

15.Lock锁

/**
 * 测试lock锁
 */
public class LockTest {
    public static void main(String[] args) {
        LockTest2 lockTest2 = new LockTest2();
        new Thread(lockTest2).start();
        new Thread(lockTest2).start();
        new Thread(lockTest2).start();
    }
}

class LockTest2 implements Runnable{

    int ticketNums = 10;
    //定义lock锁
    private final ReentrantLock lock = new ReentrantLock();

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

16.线程协作

生产者消费者模式

17.管程法

/**
 * 生产者消费者模型-->利用缓冲区解决：管程法
 * 生产者，消费者，产品，缓冲区
 */
public class PCTest {
    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 = 1; i <= 20; i++) {
            container.push(new Chicken(i));
            System.out.println("生产了"+i+"只鸡");
        }
    }
}
//消费者
class Consumer extends Thread{
    SynContainer container;

    public Consumer(SynContainer container) {
        this.container = container;
    }
    //消费
    @Override
    public void run() {
        for (int i = 1; i <= 20; i++) {
            System.out.println("消费了"+ container.pop().id+"只鸡");
        }
    }
}
//产品
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){
        //如果容器满了，就等待消费者消费
        if (count == chickens.length){
            //通知消费者消费，生产者等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //如果没满，就继续放入容器中
        chickens[count++] = chicken;
        //可以通知消费者消费了
        this.notifyAll();
    }

    //消费者消费产品
    public synchronized Chicken pop(){
        //如果容器空了，就等待生产者生产
        if (count == 0){
            //通知生产者生产，消费者等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //如果容器没空，就继续从容器中消费
        Chicken chicken = chickens[--count];
        //可以通知生产者生产了
        this.notifyAll();

        return chicken;
    }
}

18信号灯法

/**
 * 信号灯法，标志位解决
 */
public class PCTest2 {
    public static void main(String[] args) {
        TV tv = new TV();
        new Player(tv).start();
        new Watcher(tv).start();

    }
}

//演员
class Player extends Thread{
    TV tv;

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

    @Override
    public void run() {
        for (int i = 1; i <= 20; i++) {
            if (i%2 == 0){
                this.tv.play("极限挑战"+i);
            }else {
                this.tv.play("向往的生活"+i);
            }
        }
    }
}

//观众
class Watcher extends Thread{
    TV tv;

    public Watcher(TV tv) {
        this.tv = tv;
    }

    @Override
    public void run() {
        for (int i = 1; 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.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;
    }
}

19线程池

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

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

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

class MyThread implements Runnable{

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