线程

主线程调用start（）字线程执行run（）方法

多条执行路径，主线程和子线程并行交替执行

一个进程可以有多个线程，如游戏中的图像声音等

程序：指令和数据的有序集合，本身没有任何运行的含义，是一个静态概念

进程：执行程序的一次执行过程，动态概念。是系统资源分配的单位。

一个进程中包含若干个线程，且至少有一个线程，线程是cpu调度和执行的单位

很多线程是模拟出来的，真正的多线程指有多个cpu，即多核。
代码

继承Thread类

public class Thread
extends Object
implements Runnable
自定义线程类继承Thread类，重写Run()方法编写线程执行体，创建线程对象调用start()方法

package com.company.demo01;
// 线程开启不一定立即执行，由cpu调度执行
// 创建线程方式一：继承Thread类，重新Run()方法,调用Start开启线程
public class Thread01 extends Thread {public void run() {//run 方法线程体for (int i = 0; i < 30; i++) {System.out.println("test01" + i);}}public static void main(String[] args) {// 主线程//调用start()方法开启线程Thread01 thread01 = new Thread01();//thread01.start();//交替执行//thread01.run();先执行for (int i = 0; i < 30; i++) {System.out.println("test02" + i);}}
}

网图下载

1.在src下新建lib包导入io jar包右键选择 Add as library 导入资源中

package com.company.demo01;import org.apache.commons.io.FileUtils;import javax.print.DocFlavor;
import java.io.File;
import java.io.IOException;
import java.net.URL;//实现多线程同步下载图片
public class Thread02 extends Thread{private String url;//网络图片地址private String name;//保存的文件名public Thread02(String url, String name){this.url=url;this.name=name;}// 下载图片的线程执行体@Overridepublic void run() {WebDownLoader webDownLoader=new WebDownLoader();webDownLoader.downloader(url,name);System.out.println("下载文件名"+name);}public static void main(String[] args) {Thread02 thread01 = new Thread02("https://img-blog.csdnimg.cn/2020041414382368.png","1.png");Thread02 thread02 = new Thread02("https://img-blog.csdnimg.cn/20200414144400444.png","2.png");Thread02 thread03 = new Thread02("https://img-blog.csdnimg.cn/20200414144828652.png","3.png");//同时下载 交替下载，不按照顺序thread01.start();thread02.start();thread03.start();}
}// 下载器
class WebDownLoader {//下载方法public void downloader(String url, String name) {try {//网页上的地址变成文件FileUtils.copyURLToFile(new URL(url), new File(name));} catch (IOException e) {e.printStackTrace();System.out.println("IO异常downloader方法出现问题");}}
}

实现Runnable接口

定义MyRunnable接口，实现run()方法编写线程执行体，创建线程对象调用start()方法启动线程，由于java单继承的局限性 推荐使用Runnable对象。

package com.company.demo01;
//创建线程方式2：实现Runnable接口重写run()方法，执行线程需要接入Runnable接口实现类，调用start方法
public class Thread03 implements Runnable {public void run() {//run 方法线程体for (int i = 0; i < 30; i++) {System.out.println("t1" + i);}}public static void main(String[] args) {// 主线程//创建Runnable接口的实现类对象Thread03 thread03 = new Thread03();//创建线程对象，通过线程对象开启线程
//        Thread thread = new Thread(Thread03);
//        thread.start();//交替执行new Thread(thread03).start();for (int i = 0; i < 30; i++) {System.out.println("t2" + i);}}
}

package com.company.demo01;
import org.apache.commons.io.FileUtils;
import javax.print.DocFlavor;
import java.io.File;
import java.io.IOException;
import java.net.URL;//实现多线程同步下载图片
public class Thread04 implements Runnable{private String url;//网络图片地址private String name;//保存的文件名public Thread04(String url, String name){this.url=url;this.name=name;}// 下载图片的线程执行体@Overridepublic void run() {WebDownLoader02 webDownLoader02=new WebDownLoader02();webDownLoader02.downloader(url,name);System.out.println("下载文件名"+name);}public static void main(String[] args) {Thread04 thread01 = new Thread04("https://img-blog.csdnimg.cn/2020041414382368.png","1.png");Thread04 thread02 = new Thread04("https://img-blog.csdnimg.cn/20200414144400444.png","2.png");Thread04 thread03 = new Thread04("https://img-blog.csdnimg.cn/20200414144828652.png","3.png");//同时下载 交替下载，不按照顺序new Thread(thread01).start();new Thread(thread02).start();new Thread(thread03).start();}
}// 下载器
class WebDownLoader02 {//下载方法public void downloader(String url, String name) {try {//网页上的地址变成文件FileUtils.copyURLToFile(new URL(url), new File(name));} catch (IOException e) {e.printStackTrace();System.out.println("IO异常downloader方法出现问题");}}
}

龟兔赛跑

package com.company.demo01;
//模仿龟兔赛跑
public class Race implements Runnable {//胜利者private static String winner;@Overridepublic void run() {for (int i = 0; i <= 100; i++) {//模拟兔子休息if (Thread.currentThread().getName().equals("兔子")){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 steps) {// 判断是否有胜利者if (winner != null) {return true;}{if (steps >= 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();}
}

实现Callable接口

1.实现Callable接口，需要返回值类型。
2.重写call方法，需要抛出异常
3.创建目标对象
4.创建执行服务：ExecutorService ser=Executors.newFixedThreadPool(1);
5.提交执行:Future<Boolean>result1=ser.submit(t1);
6.获取结果:boolean r1=result.get()
7.关闭服务:ser.shutdownNow();

package com.company.demo01;
import org.apache.commons.io.FileUtils;
import sun.tools.tree.AddExpression;
import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.util.concurrent.*;//创建线程方式三：实现Callable方式
public class TestCallable implements Callable<Boolean > {private String url;//网络图片地址private String name;//保存的文件名public TestCallable(String url, String name){this.url=url;this.name=name;}// 下载图片的线程执行体@Overridepublic 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 {TestCallable T01 = new TestCallable("https://img-blog.csdnimg.cn/2020041414382368.png","1.png");TestCallable T02 = new TestCallable("https://img-blog.csdnimg.cn/20200414144400444.png","2.png");TestCallable T03 = new TestCallable("https://img-blog.csdnimg.cn/20200414144828652.png","3.png");//创建执行服务：ExecutorService ser= Executors.newFixedThreadPool(3);//提交执行Future<Boolean> result1=ser.submit(T01);Future<Boolean> result2=ser.submit(T02);Future<Boolean> result3=ser.submit(T03);//获取结果:boolean r1=result1.get();boolean r2=result2.get();boolean r3=result3.get();//关闭服务ser.shutdownNow();}
}// 下载器
class WebDownLoader2 {//下载方法public void downloader(String url, String name) {try {//网页上的地址变成文件FileUtils.copyURLToFile(new URL(url), new File(name));} catch (IOException e) {e.printStackTrace();System.out.println("IO异常downloader方法出现问题");}}}

静态代理模式

package com.company.demo02;
//代理模式
/*
* 1.真实对象和代理对象都要实现同一个接口
* 2.代理对象代理真实对象
* 3.代理对象扩展真实对象功能
我是真实的喜欢是代理的
* */
public class StaticProxy {public static void main(String[] args) {like l1= new like(new me());l1.One();//        me m1=new me();
//        new Thread(()-> System.out.println("test")).start();
//        new like(new me()).One();}}interface Fill {void One();
}//真是角色
class me implements Fill {public void One() {System.out.println("one");}}//代理角色
class like implements Fill {//代理对象代理真实对象private Fill target;public like(Fill target) {this.target = target;}public void One() {before();this.target.One();//真实对象after();}private  void after(){System.out.println("之后");}private  void before(){System.out.println("开始之前");}
}

Lamda表达式

1.希腊字母第十一位 ”入“
2.避免匿名内部类定义过多
3.实质属于函数式编程的概念

a-> System.out.println("landa"+a);
new Thread(()->System.out.println("lanmda")).start();

1.函数式接口的定义：任何接口，如果只包含唯一一个抽象方法，那么它就是一个函数式接口。
2.对于函数式接口可以通过lamda表达式来创建该接口

package com.company.demo02;/*** 推导lamda表达式*/
public class TestLamda01 {//3.静态内部类static class Olike2 implements Ilike {public void lamda() {System.out.println("two lamda");}}public static void main(String[] args) {Ilike ilike = new Olike();ilike.lamda();ilike = new Olike2();ilike.lamda();//4.局部内部类class Olike3 implements Ilike {public void lamda() {System.out.println("three lamda");}}ilike = new Olike3();ilike.lamda();//5.匿名内部类,没有类的名称必须借助接口或者父类ilike = new Ilike(){public void lamda(){System.out.println("four lamda");}}; ilike.lamda();//6.lamda简化ilike=()->{System.out.println("five lamda");};ilike.lamda();}
}//1.定义一个函数式接口
interface Ilike {void lamda();
}//2.实现类
class Olike implements Ilike {@Overridepublic void lamda() {System.out.println("one lamda");}
}

package com.company.demo02;
//lamda表达式只能有一行代码简化，多行用代码块 函数式接口专用
public class TestLamda02 {public static void main(String[] args) {
//        Ilove ilove=(int a)->{
//            System.out.println(" lamda"+a);
//
//        };
//        ilove.love(2);
//        //1.简化去掉参数类型 去掉完 a,b,c...但必须加上括号  没有类的名称必须借助接口或者父类
//         ilove=( a)->{
//            System.out.println(" lamda"+a);
//
//        };
//        ilove.love(3);
//        //2.去掉括号
//        ilove=a -> {
//            System.out.println(" lamda"+a);
//
//        }; ilove.love(4);
//        //3.去掉花括号
//        ilove=a -> System.out.println(" lamda"+a); ilove.love(5);Ilove  ilove=a -> System.out.println(" lamda"+a); ilove.love(6);}
}
interface  Ilove{void love(int a);
}

线程停止

1.使用标志位进行终止变量当 flag=false，则终止线程运行

package com.company.demo03;
//停止线程
/*
1.线程正常停止-->利用次数,不建议死循环
2.使用标志位
3.不使用stop或者destroy过时的方法*/
public class TestStop implements Runnable {//1.设置一个标志位private boolean flag=true;@Overridepublic void run() {int i=0;while (flag){System.out.println("test"+i++);}}//设置一个公开的方法停止线程，转换标志位public void stop(){this.flag=false;}public static void main(String[] args) {TestStop testStop=new TestStop();new Thread(testStop).start();for (int i = 0; i < 1000; i++) {System.out.println("MAIN"+i);if (i==900) {//调用stop方法切换标志位，让线程停止testStop.stop();System.out.println("线程停止");}}}
}

线程休眠—sleep

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

package com.company.demo03;import com.company.demo01.Thread05;import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.logging.SimpleFormatter;//模拟网络延迟 放大问题发生性
//模拟倒计时
public class TestSleep {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();
//        }}public static void tenDown() throws InterruptedException {int num=10;while (true){Thread.sleep(1000);System.out.println("num"+num--);if (num <=0) {break;}}}
}

线程礼让—yield

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

package com.company.demo03;
//测试礼让 礼让不一定成功
public class TestYield {public static void main(String[] args) {MyYield myYield = new MyYield();new Thread(myYield,"a").start();new Thread(myYield,"b").start();}}class MyYield implements Runnable{@Overridepublic void run() {System.out.println(Thread.currentThread().getName()+"线程开始");Thread.yield();//礼让System.out.println(Thread.currentThread().getName()+"线程停止");}
}

线程强制执行_join

1.join 合并线程，待线程执行完毕后，再执行其他线程，其他线程阻塞
2.插队

package com.company.demo03;
//测试join方法
public class TestJoin implements  Runnable {@Overridepublic void run() {for (int i = 0; i < 100; i++) {System.out.println("线程VIP"+i);}}public static void main(String[] args) throws InterruptedException {//启动线程Thread thread= new Thread(new TestJoin());thread.start();//主线程for (int i = 0; i < 500; i++) {if (i == 200) {thread.join();//插队}System.out.println("main"+i);}}
}

观测线程状态

线程状态。 线程可以处于以下状态之一：
NEW 
尚未启动的线程处于此状态。
RUNNABLE 
在Java虚拟机中执行的线程处于此状态。
BLOCKED 
被阻塞等待监视器锁定的线程处于此状态。
WAITING 
正在等待另一个线程执行特定动作的线程处于此状态。
TIMED_WAITING 
正在等待另一个线程执行动作达到指定等待时间的线程处于此状态。
TERMINATED 
已退出的线程处于此状态。
一个线程可以在给定时间点处于一个状态。 这些状态是不反映任何操作系统线程状态的虚拟机状态。

package com.company.demo03;import com.sun.javafx.scene.control.skin.TableHeaderRow;
//进入死亡不可重新启动
public class TestState {public static void main(String[] args) throws InterruptedException {Thread thread=new Thread(()->{for (int i = 0; i < 5; i++) {try {Thread.sleep(100);} 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);//runwhile (state !=Thread.State.TERMINATED){// 只要线程不终止 就一直输出状态Thread.sleep(100);state=thread.getState();//更新线程状态System.out.println(state);}}}

线程的优先级

1.java 提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度器按照优先级决定应该调度那个线程来执行
2.线程的优先级用数字1~10来表示
Thread.MIN_PRIORTY=1;
Thread.NORM_PRIORTY=5;
Thread.MAX_PRIORTY=10;
3.使用 getPriority() setPriority(int xxx)来改变或获取优先级
4.主要看cpu优先级的设定建议在start()调度前

package com.company.demo03;
//测试线程优先级
public class TestPriority {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);//先设置优先级 再启动t1.start();t2.setPriority(1);t2.start();t3.setPriority(4);t3.start();t4.setPriority(Thread.MAX_PRIORITY);t4.start();t5.setPriority(8);t5.start();}
}class MyPriority implements Runnable{@Overridepublic void run() {System.out.println(Thread.currentThread().getName()+"--"+Thread.currentThread().getPriority());}
}

守护线程

1.线程分为用户线程和守护线程(daemon)
2.虚拟机必须确保用户线程执行完毕
3.虚拟机不用等待守护线程执行完毕
4.如，后台纪录操作，监控内存，垃圾回收等

package com.company.demo03;
//测试守护线程public class TestDaemon {public static void main(String[] args) {Country country = new Country();Me me = new Me();Thread thread = new Thread(country);thread.setDaemon(true);//默认false表示用户线程 正常的线程都是用户线程thread.start();//守护线程启动new Thread(me).start();//用户线程启动}
}//国家
class Country implements  Runnable{@Overridepublic void run() {while (true){System.out.println("守护每一天");}}
}
//我
class Me implements Runnable{@Overridepublic void run() {for (int i = 0; i < 36500; i++) {System.out.println("每天被守护");}System.out.println("谢谢");}
}

线程的同步机制

1.多个线程操作同一个资源
2.并发：同一个对象被多个线程同时操作
3.线程同步是一种等待机制，多个需要同时访问此对象的线程进入这个对象的等待池形成对列，等待前面线程使用完毕下一个线程再使用。
4.锁：每个对象都有一把锁
5.线程同步形成条件：对列+锁  
6.锁机制：synchronized，当一个线程获得对象的排它锁，独占资源，其他线程必须等待，使用后释放锁即可。

三大不安全案例

package com.company.syn;
//不安全买票,买到负票
public class UnsafeBuyTicket {public static void main(String[] args) {BuyTicket buyTicket = new BuyTicket();new Thread(buyTicket,"a").start();new Thread(buyTicket,"b").start();new Thread(buyTicket,"c").start();}
}class BuyTicket implements Runnable{//票private int ticketNums=10;boolean flag=true;//外部停止方式@Overridepublic void run() {//买票while (flag){try {buy();} catch (InterruptedException e) {e.printStackTrace();}}}//锁 this本身private synchronized void buy() throws InterruptedException {//判断是否有票if (ticketNums <=0) {flag=false;return;}//模拟延迟Thread.sleep(100);//买票System.out.println(Thread.currentThread().getName()+"拿到"+ticketNums--);}
}

package com.company.syn;
//不安全的取钱
//两个人去银行取钱
public class UnsafeBank {public static void main(String[] args) {Account account = new Account("投资基金",100);Drawing boy=new Drawing(account,50,"a");Drawing girl=new Drawing(account,100,"b");boy.start();girl.start();}
}//账户
class Account{int money;//余额String name;//卡名public Account(String name ,int money ) {this.name = name;this.money = money;}}
//银行：模拟取钱
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;}//取钱@Overridepublic  void run() {//锁的对象就是变化的量，需要增删改synchronized (account){//判断是否有钱if (account .money-drawingMoney<0) {System.out.println(Thread.currentThread().getName()+"钱不够");return;}//模拟延迟 sleep放大问题的发生性try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}//卡内余额account.money=account.money-drawingMoney;//手里的钱nowMoney=+drawingMoney;System.out.println(account.name+"余额为"+account.money);//this.getName()==Thread.currentThread().getName()System.out.println(this.getName()+"手里的钱"+nowMoney);  }}
}

package com.company.syn;
import java.util.ArrayList;
import java.util.List;
public class UnsafeList {public static void main(String[] args) {List<String> list = new ArrayList<>();for (int i = 0; i < 10000; i++) {new Thread(()->{synchronized (list){list.add(Thread.currentThread().getName());}).start();}try {Thread.sleep(2000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(list.size());}
}

同步方法及同步块

同步块：synchronized(Obj){}
Obj 称之为同步监视器
1.Obj可以是任何对象，但是推荐使用共享资源作为同步监视器
2.同步方法中无需指定同步监视器，因为同步方法的同步监视器就是this就是这个对象的本身，或者是class
3.同步监视器的执行过程
第一个线程访问，锁定同步监视器，执行其中代码
第二个线程访问，发现同步监视器被锁定，无法访问
第一个线程访问完毕，解锁同步监视器
第二个线程访问，发现同步监视器没有锁，然后锁定并访问

CopyOnWriteArrayList

package com.company.syn;import java.util.concurrent.CopyOnWriteArrayList;//测试JUC安全类型的集合
public class TestJUC {public static void main(String[] args) {CopyOnWriteArrayList list=new CopyOnWriteArrayList<>();for (int i = 0; i < 10000; i++) {new Thread(()->{list.add(Thread.currentThread().getName()) ;}).start();}try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(list.size());}
}

死锁

1.某一个同步块同时用哟偶“两个以上对象的锁”就可能发生死锁
2.产生死锁的四个必要条件：1.互斥条件：一个资源每次只能被一个进程使用2.请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放3.不剥夺条件：进程已获得的资源，在未使用完之前，不能强行剥夺4.循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系。

Lock锁

1.显示定义同步锁对象来实现同步，同步锁使用look对象充当
2.java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Look对象加锁，线程开始访问资源之前应先获得Look对象
3.ReentrantLock类实现了Lock，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显示加锁，释放锁。

1.lock是现实锁（手动开启和关闭锁）synchronized是隐式锁，除了作用域自动释放
2.lock只有代码块锁，synchronized有代码块锁和方法锁
3.lock>同步代码块（已经进入了方法体，分配了相应资源）>同步方法(在方法体之外)

package com.company.syn;import java.util.concurrent.locks.ReentrantLock;//测试lock锁
public class TestLock {public static void main(String[] args) {TestLock2 t2 = new TestLock2();TestLock2 t3 = new TestLock2();TestLock2 t4= new TestLock2();new Thread(t2,"a").start();new Thread(t3,"b").start();new Thread(t4,"c").start();}
}
class TestLock2 implements  Runnable{int ticketNums=10;//定义Lock锁private  final  ReentrantLock lock=new ReentrantLock();@Overridepublic void run() {while (true){try {lock.lock();//加锁if (ticketNums >0) {try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName()+ticketNums--);}else {break;}}finally {//解锁lock.unlock();}}}
}

生产者消费者问题

1.线程协作 
2.synchronized可阻止并发更新同一个共享资源，实现了同步
3.synchronized不能用来实现不同线程之间的消息传递（通信）
1.解决通信的方法：1.wait()  表示线程一直等待直到其他线程通知，与sleep不同会释放锁2.wait(long timeout)  指定等待的毫秒数3.notify()  唤醒一个处于等待状态的线程4.notifyAll() 唤醒同一个对象上所有调用wait()方法的线程，优先级>5.均是Object类的方法，都只能在同步方法或同步代码块中使用

管程法

package com.company.over;//测试生产者消费者模型-->利用缓冲区解决：管程法
//生产者 消费者 产品 缓冲区
public class TestProducer {public static void main(String[] args) {Syncontainer container = new Syncontainer();new Producer(container).start();new Consumer(container).start();}
}//生产者
class Producer extends Thread {Syncontainer container;public Producer(Syncontainer container) {this.container = container;}//生产@Overridepublic void run() {for (int i = 0; i < 100; i++) {container.push(new Chicken(i));System.out.println("生产力" + i + "只鸡");}}
}//消费者
class Consumer extends Thread {Syncontainer container;public Consumer(Syncontainer container) {this.container = container;}//消费@Overridepublic void run() {for (int i = 0; i < 100; 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;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.company.over;
//测试生产者消费者模型-->信号灯法，标志位解决
public class TestPc2 {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;}@Overridepublic void run() {for (int i = 0; i < 20; i++) {if (i %2==0) {this.tv.play("BBC start");}else {this.tv.play("youtube start");}}}
}
//消费者-->观众
class Watcher extends Thread{Tv tv;public  Watcher(Tv tv) {this.tv=tv;}@Overridepublic 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 ==true) {try {this.wait();} catch (InterruptedException e) {e.printStackTrace();}}System.out.println("观看了"+voice);//通知演员表演this.notifyAll();this.flag=!this.flag;}
}

线程池

1.提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。
2.可以避免频繁创建和销毁，实现重复利用，提高响应速度，降低资源消耗，便于线程管理。
3.ExecutorService:真正的线程池接口。常见的子类ThreadPoolExecutor
4.Executors:工具类，线程池的工厂类，用于创建并返回不同类型的线程池

package com.company.over;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class TestPool {public static void main(String[] args) {//创建线程池 newFixedThreadPool 参数为线程池大小ExecutorService service= Executors.newFixedThreadPool(10);//执行service.execute(new MyThread());service.execute(new MyThread());service.execute(new MyThread());service.execute(new MyThread());//关闭连接service.shutdown();}
}class MyThread implements Runnable{@Overridepublic void run() {System.out.println(Thread.currentThread().getName());}
}

总结

package com.company.summarize;import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.FutureTask;//总结线程创建
public class TestOver {public static void main(String[] args) {new MyThread1().start();new Thread(new MyThread2()).start();FutureTask<Integer> futureTask=new FutureTask<Integer>(new MyThread3());new Thread(futureTask).start();try {Integer integer=futureTask.get();System.out.println(integer);} catch (InterruptedException e) {e.printStackTrace();} catch (ExecutionException e) {e.printStackTrace();}}}
//1.继承Thread类
class MyThread1 extends Thread{@Overridepublic void run() {System.out.println("MyThread1");}
}
//2.实现Runnable接口
class MyThread2 implements Runnable{@Overridepublic void run() {System.out.println("MyThread2");}
}
//3.实现Callable接口
class MyThread3 implements Callable<Integer>{@Overridepublic Integer call() throws Exception {System.out.println("MyThread3");return 111;}
}