06Java多线程---超详细回顾、Thread、Runnable、Cakkable、Lambda、锁Lock和synchronized等
线程简介
任务
例子 边吃饭边玩手机 ,边开车 边打电话 都算多任务
- 看起来多个任务在做,其实本质上大脑在同一时间只做了一件事情
多线程
例子 原来是一条路,慢慢因为车太多了道路拥塞,所以加了多个车道。
普通方法调用和多线程
程序 进程 线程
-
在操作系统中运行的程序就是进程,比如你的QQ,游戏等
-
一个进程里会有多个线程,比如视频 同时显示图像,声音,字幕
- 程序是指令和数据的有序集合,其本身没有任何运行概念,是一个静态的概念
- 进程则是执行程序的一次执行过程,是一个动态的概念。是系统资源分配的单位
- 一个进程可以包含多个线程,线程是CPU调度和执行的单位 例如main函数就是主线程
注意!
核心概念
线程创建三种方式
Thread
- 自定义线程类继承Thread类
- 重写run()方法,编写线程执行体
- 创建线程对象,调用start()方法启动线程
线程开启不一定立即执行,由CPU调度执行
package com.ybl.demo1;
//继承thread类 重写run方法,调用start
public class TestThread extends Thread {
@Override
public void run() {
//run方法线程体
for (int i = 0; i <20 ; i++) {
System.out.println("我在看代码---"+i);
}
}
public static void main(String[] args) {
//main线程,主线程
//创建一个线程对象
TestThread testThread = new TestThread();
//调用start()方法开启
// 调用run()的话就先执行run()
testThread.start();
for (int i = 0; i < 20; i++) {
System.out.println("我在学多线程---"+i);
}
}
}
#运行结果,两个线程同时执行
我在学多线程---0
我在看代码---0
我在学多线程---1
我在学多线程---2
我在学多线程---3
我在学多线程---4
我在学多线程---5
我在学多线程---6
我在学多线程---7
我在学多线程---8
我在学多线程---9
我在学多线程---10
我在学多线程---11
我在学多线程---12
我在学多线程---13
我在学多线程---14
我在学多线程---15
我在学多线程---16
我在学多线程---17
我在学多线程---18
我在学多线程---19
我在看代码---1
我在看代码---2
我在看代码---3
我在看代码---4
我在看代码---5
我在看代码---6
我在看代码---7
我在看代码---8
我在看代码---9
我在看代码---10
我在看代码---11
我在看代码---12
我在看代码---13
我在看代码---14
我在看代码---15
我在看代码---16
我在看代码---17
我在看代码---18
我在看代码---19
多线程实现网图下载
- 先下载commons IO jar包 (百度搜索commons IO
- 创建一个lib目录,复制进去jar包
- 右键添加为lib
代码
package com.ybl.demo1;
import org.apache.commons.io.FileUtils;
import java.io.File;
import java.io.IOException;
import java.net.URL;
//练习Thread,实现多线程同步下载图片
public class TestThread2 extends Thread {
private String url;
private String name;
public TestThread2(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) {
TestThread2 testThread2 = new TestThread2("https://img-home.csdnimg.cn/images/20210325065903.jpg","2.jpg");
TestThread2 testThread3 = new TestThread2("https://img-home.csdnimg.cn/images/20210325065903.jpg","3.jpg");
TestThread2 testThread4 = new TestThread2("https://img-home.csdnimg.cn/images/20210325065903.jpg","4.jpg");
testThread2.start();
testThread3.start();
testThread4.start();
}
}
class WebDownloader{
public void downloader(String url,String name){
try {
FileUtils.copyURLToFile(new URL(url),new File(name));
} catch (IOException e) {
e.printStackTrace();
}
}
}
Runnable 接口实现
推荐使用runnable接口
该方法便面了单继承的局限性,灵活方便,方便同一个对象被多个线程使用
//创建线程方式2:实现runable接口,重现run方法,执行线程需要runable接口实现类,调用start方法
public class TestThread3 implements Runnable {
public void run() {
//run方法线程体
for (int i = 0; i <20 ; i++) {
System.out.println("我在看代码---"+i);
}
}
public static void main(String[] args) {
//创建runnablr接口实现类对象
TestThread3 testThread3 = new TestThread3();
//创建线程对象,通过线程对象来开启我们的线程,代理
Thread thread =new Thread(testThread3); //把实现类对象丢进来
thread.start();
for (int i = 0; i < 20; i++) {
System.out.println("我在学多线程---"+i);
}
}
}
初识并发问题
//发现问题,多个线程操作同意给资源的情况下,线程不安阿全,数据紊乱
//发现问题,多个线程操作同意给资源的情况下,线程不安阿全,数据紊乱
public class TestThread4 implements Runnable{
int tickeNums=10; //操作同一个对象,所以可以用一个计票来技术。
@Override
public void run() {
while (true){ //Thread.currentThread().getName() 获得当前线程的名字
if(tickeNums<=0){
break;
}
//模拟延时
try {
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"拿到了第"+tickeNums--+"票");
}
}
public static void main(String[] args) {
TestThread4 testThread4 = new TestThread4();//创建了一个实现
new Thread(testThread4,"小猫").start();
new Thread(testThread4,"小狗").start();
new Thread(testThread4,"小牛").start();
}
}
小猫拿到了第10票
小狗拿到了第8票
小牛拿到了第9票
小猫拿到了第7票
小狗拿到了第6票 // 6号票被拿了两次
小牛拿到了第6票
小狗拿到了第5票
小牛拿到了第4票
小猫拿到了第3票
小狗拿到了第2票
小牛拿到了第1票
小猫拿到了第0票
Process finished with exit code 0
龟兔赛跑多线程
package com.ybl.demo1;
public class Race implements Runnable{
private static String winner;
@Override
public void run() {
for (int i = 0; i < 101; i++) {
//模拟兔子休息
if(Thread.currentThread().getName().equals("兔子")&&i%10==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 steps){
if(winner!=null){
return true;
}else{
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接口 (了解即可
- 实现Callable接口,需要返回值类型
- 重写call方法,需要抛出异常
- 创建目标对象
- 创建执行服务
ExecutorService ser=Executors.newFixedThreadPool(1);
- 提交执行
Future<Boolean> result1=ser.submit(t1);
- 获取结果
boolean r1=result1.get()
- 关闭服务
ser.shutdownNow();
package com.ybl.demo1;
import java.util.concurrent.*;
/*
Callable好处
1.可以定义返回值
2.可以抛出异常
*/
public class TestCallable implements Callable<Boolean> {
private String url;
private String name;
public TestCallable(String url, String name) {
this.url = url;
this.name = name;
}
//下载图片线程的执行体
public Boolean call() {
WebDownloader webDownloader = new WebDownloader();
webDownloader.downloader(url,name);;
System.out.println("下载了文件名"+name);
return true;
}
public static void main(String[] args) throws ExecutionException, InterruptedException {
TestCallable t1 = new TestCallable("https://img-home.csdnimg.cn/images/20210325065903.jpg","2.jpg");
TestCallable t2 = new TestCallable("https://img-home.csdnimg.cn/images/20210325065903.jpg","3.jpg");
TestCallable t3 = new TestCallable("https://img-home.csdnimg.cn/images/20210325065903.jpg","4.jpg");
//1. 创建执行服务` 创建了一个线程池 有三个线程
ExecutorService ser= Executors.newFixedThreadPool(3);
//2. 提交执行`
Future<Boolean> result1=ser.submit(t1);
Future<Boolean> result2=ser.submit(t2);
Future<Boolean> result3=ser.submit(t3);
//3. 获取结果`
boolean rs1=result1.get();
boolean rs2=result2.get();
boolean rs3=result3.get();
System.out.println(rs1);
System.out.println(rs2);
System.out.println(rs3);
//4.关闭服务`
ser.shutdownNow();
}
}
静态代理-Runable底部实现原理
代理:就是别人帮你做事情
从静态代理方面来理解 Thread和Runnable接口和实现Runnable接口的类之间的关系
package com.ybl.demo2;
//静态代理模式总结
/*
真实对象和代理对象都要实现同一个接口
代理对象和代理真实角色
//好处
代理对象可以做很对真实对象做不了的事情
真实对象专注做自己的事情
*/
public class StaticProxy {
public static void main(String[] args) {
// You you = new You();
// WeddingCompany weddingCompany = new WeddingCompany(you);
// weddingCompany.HappyMarry();
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("我要结婚了");
}
}).start();
new WeddingCompany(new You()).HappyMarry();
//其实这个例子和thread 相似,,thread和wedcompany都实现了一个接口,然后you和实现runnable接口的类,然后通过代理来调用方法
}
}
interface Marry{
//人间四大喜事
//久旱逢甘霖
//他乡遇故知
//洞房花烛夜
//金榜题名时
void HappyMarry();
}
//真实角色,你去结婚 对应实现runnable接口的类
class You implements Marry{
@Override
public void HappyMarry() {
System.out.println("我结婚了");
}
}
//代理角色 帮助你结婚 对应Thread
class WeddingCompany implements Marry{
//代理真实目标角色
private Marry target;
WeddingCompany(Marry target) {
this.target = target; //这就是真实对象
}
@Override
public void HappyMarry() {
before();
this.target.HappyMarry();
after();
}
private void after() {
System.out.println("结婚之后收尾款");
}
private void before() {
System.out.println("结婚之前布置现场");
}
}
Lambda表达式
- 避免匿名内部类定义过多
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("我要结婚了");
}
}).start();
//可以写成
new Thread(()->System.out.println("我要结婚了")).start();
函数式接口
定义:
- 任何接口,如果只包含唯一一个抽象方法,那么他就是一个函数式接口
public interface Runnable{
public abstract void run();
}
- 对于函数式接口,我们可以用lambda表达式来创建该接口对象(接口实例化 new一个它的实现类
package com.ybl.demo3;
public class TestLambda1 {
//3.静态内部类
static class Like2 implements Ilike{
@Override
public void lambda() {
System.out.println("i like lambda2");
}
}
public static void main(String[] args) {
//2.最基本的
Ilike like = new Like();
like.lambda();
//3.静态内部类
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=(int a)->{
System.out.println("i like lambda5"+a);
};
like.lambda(2);
like=(a)->{
System.out.println("i like lambda5"+a);
};
like=a->{
System.out.println("i like lambda5"+a);
};
like=a->System.out.println("i like lambda5"+a);
}
}
//1.定义一个函数时接口
interface Ilike{
void lambda();
}
//2.实现类
class Like implements Ilike{
@Override
public void lambda() {
System.out.println("i like lambda");
}
}
简化lambda 表达式
like=(int a)->{//1
System.out.println("i like lambda5"+a);
};
like.lambda(2);
like=(a)->{//2
System.out.println("i like lambda5"+a);
};
like=a->{//3
System.out.println("i like lambda5"+a);
};
//4
like=a->System.out.println("i like lambda5"+a);
- lambda表达式只有参数和行数为1行才能简化成这样
- 多个参数也可以去掉参数类型,但必须加括号,
线程的五大状态
- 创建状态 new Thread()
- 启动线程 调用start() 就绪状态
- 获得CPU之后进入 运行状态
- sleep()等方法进入阻塞状态
- 阻塞解除后进入就绪状态
- 正常执行完之后进入死亡状态
线程方法
线程停止
一旦线程死亡之后 就不能再次启动
package com.ybl.state;
/*
1.建议线程正常停止---->利用次数,不建议死循环
2.使用标志位-->设置一个flag
3.不要使用stop或者destroy 等过时方法
*/
public class TestSTop implements Runnable{
//1,设置一个标志位
private boolean flag=true;
@Override
public void run() {
int i=0;
while (flag){
System.out.println("run---thread--"+i++);
}
}
//2.设置一个公开的方法停止线程,转换标志位
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++) {
if(i==900){
//调用stop方法切换标志位 让线程停止
testSTop.stop();
System.out.println("线程停止了");
}
}
}
}
线程休眠
import java.text.SimpleDateFormat;
import java.util.Date;
//模拟倒计时
public class TestSleep2 {
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);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(new SimpleDateFormat("HH:MM:ss").format(startTime));
startTime=new Date(System.currentTimeMillis());
}
}
}
14:03:02
14:03:03
14:03:04
14:03:05
14:03:06
14:03:07
14:03:08
14:03:09
14:03:10
线程礼让
//测试礼让线程
//礼让不一定成功 看CPU心情
public class TestYield {
public static void main(String[] args) {
Myyileld myyileld = new Myyileld();
new Thread(myyileld,"A").start();
new Thread(myyileld ,"B").start();
}
}
class Myyileld implements Runnable{
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"线程开始执行");
Thread.yield();//礼让
System.out.println(Thread.currentThread().getName()+"线程停止执行");
}
}
Join 插队
package com.ybl.state;
public class TestJoin implements Runnable{
@Override
public void run() {
for (int i = 0; i <100; i++) {
System.out.println("线程vip来了"+i);
}
}
public static void main(String[] args) throws InterruptedException {
TestJoin testJoin = new TestJoin();
Thread thread=new Thread(testJoin);
thread.start();;
for (int i = 0; i < 1000; i++) {
if (i==200){
thread.join();//插队
}
System.out.println("main"+i);
}
}
}
观测线程状态
package com.ybl.state;
import com.sun.javaws.IconUtil;
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(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("-=-=---=");
}
});
//观察状态
Thread.State state=thread.getState();
System.out.println(state);
//观察启动后
thread.start();
state=thread.getState();
System.out.println(state);
while(state!=Thread.State.TERMINATED){
//只要线程不终止 就一直输出状态
Thread.sleep(100);
state=thread.getState();
System.out.println(state);
}
//错误 死亡之后的进程不能再次启动
//thread.start();
}
}
- 一旦线程死亡之后就不能再次启动
线程优先级
线程优先级用数字表示,范围从1~10
- Thread.MIN_PRIORITY=1;
- Thread.MAX_PRIORITY=10;
- Thread.Norm_Priority=5;
使用以下方式改变或获取优先级
- getPriority()
- setPriority(int xxx)
优先级的设定建议在start()调度前
优先级低知识意味着获得调度的概率低,并不是优先级低就不会被调用了,这都看CPU;
package com.ybl.state;
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);
Thread t6=new Thread(mypriority);
//先设置优先级在启动
t1.start(); //默认优先级是5 main也是5
t2.setPriority(1);
t2.start();
t3.setPriority(4);
t3.start();
}
}
class Mypriority implements Runnable{
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"--->"+Thread.currentThread().getPriority());
}
}
守护线程 daemon
- 线程分为用户线程和守护线程
- 虚拟机确保用户线程执行完毕 —main
- 虚拟机不用等待守护线程执行完毕
- 如后台记录操作日志,监控内存,垃圾回收
package com.ybl.state;
public class TestDaemon {
public static void main(String[] args) {
God god=new God();
You you = new You();
Thread thread= new Thread(god);
thread.setDaemon(true); //默认false是用户线程 ,正常的都是用户线程
thread.start();//上帝守护线程
new Thread(you).start(); //你 用户线程 该进程结束之后 守护进程过一会停止。
}
}
class You implements Runnable{
@Override
public void run() {
for (int i = 0; i < 365; i++) {
System.out.println("你开心的活着");
}
System.out.println("========good bye world========");
}
}
class God implements Runnable{
@Override
public void run() {
while (true){
System.out.println("上帝保佑着你");
}
}
}
线程同步
并发:同一个对象被多个线程同时操作
多个线程访问同一个对象,并且某些线程还想修改这个对象,这时候我们就需要线程同步。线程同步其实就是一种等待机制,多个需要同时访问此对象的线程进入这个对象的等待池形成队列,等待前面线程使用完毕,下一个线程再使用。
队列和锁
线程同步 需要队列和锁,一个例子就是厕所,你上厕所需要排队形成了队列,进入厕所之后锁上门,形成了锁,sleep()的时候不会释放锁。
为了保证数据在方法中被访问的正确性,在访问的时候加入锁机制synchronized,当一个线程获得对象的排他锁,独占资源,其他线程必须等待,使用后释放锁即可。存在以下问题:
- 降低性能,一个线程持有锁会导致其他所有此锁的线程挂起
- 在多线程竞争下,加锁,释放锁会导致比较多的上下文切换和调度延时,引起性能问题
- 如果一个优先级高的线程等待一个优先级低的线程释放锁,会导致优先级倒置,引起性能问题
package com.ybl.syn;
import java.util.ArrayList;
import java.util.List;
public class UnsafeList {
public static void main(String[] args) {
List<String> list =new ArrayList<String>();
for (int i = 0; i < 1000; i++) {
new Thread(()->{
list.add(Thread.currentThread().getName());
}).start();
}
System.out.println(list.size()); //打印出来998说明 有线程重复操作List,而且List是不安全的
}
}
同步方法
synchronized包括两种用法
synchronized方法和synchronized块
public synchronized void method(int arge){}
- synchronized 方法控制对“对象”的访问,每个对象对应一把锁,每个synchronized方法必须获得调用该方法的对象的锁才能执行,否则线程会阻塞,方法一旦执行,就独占该锁,直到改方法返回才释放锁。
需要注意的是 synchronized方法默认锁当前方法的对象就是this,而synchronized块可以锁其他对象,这个块锁的对象就是变化的量,需要增删改的对象
- 车票变化类ticket中要操作的属性ticketnum就在run()方法的类中,这时候锁就直接锁掉了,而银行Bank中要操作的属性account在别的类中,run在Bank中,这时候锁run没有用,因为操作的对象是account而不是bank
package com.ybl.syn;
import java.util.ArrayList;
import java.util.List;
public class UnsafeList {
public static void main(String[] args) throws InterruptedException {
List<String> list =new ArrayList<String>();
for (int i = 0; i < 1000; i++) {
new Thread(()->{
synchronized (list){
list.add(Thread.currentThread().getName());
}
}).start();
}
//注意这里要sleep一下,因为不加的话主线程提前跑完,其他线程还在运行中,导致现实的结果小于1000
Thread.sleep(3000);
System.out.println(list.size());
}
}
另外一种写法,引用安全的包
import java.util.concurrent.CopyOnWriteArrayList;
//测试JUC安全类型的几何
public class TsetJUC {
public static void main(String[] args) {
CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<String>();
for (int i = 0; i < 1000; i++) {
new Thread(()->list.add(Thread.currentThread().getName())).start();
}
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(list.size());
}
}
同步方法弊端
- 方法里面需要修改的内容才需要所,锁太多,浪费资源
死锁
某一个同步块同时拥有“两个以上对象的锁”时,就有可能发生死锁问题
死锁:多个线程互相抱着对方需要的资源,然后形成僵持
package com.ybl.syn;
//死锁:多个线程互相抱着对方需要的资源,然后形成僵持
public class DeadLock {
public static void main(String[] args) {
Makeup a = new Makeup(0, "A");
Makeup b = new Makeup(1, "B");
a.start();
b.start();
}
}
class Lipstick{
}
class Mirror{
}
class Makeup extends Thread{
//需要的资源只有一份,用static来表示
static Lipstick lipstick=new Lipstick();
static Mirror mirror =new Mirror();
int choice;
String grilName;
public Makeup(int choice, String grilName) {
this.choice = choice;
this.grilName = grilName;
}
@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.grilName+"获得口号的锁");
Thread.sleep(1000);
synchronized (mirror){
System.out.println(this.grilName+"获得镜子的锁");
}
}
}else{
synchronized (mirror){//获得镜子的锁
System.out.println(this.grilName+"获得镜子的锁");
Thread.sleep(2000);
synchronized (lipstick){
System.out.println(this.grilName+"获得口红的锁");
}
}
}
}
}
//改例子中,A在获得口红资源之后 不释放的情况下,去占有另外一个资源,会导致死锁,所以把里面的synchronized放到外面来
产生死锁的四个条件
- 互斥条件:一个资源每次只能被一个线程使用
- 请求与保持条件:一个线程因请求资源而阻塞时,对以获得的资源保持不妨
- 不剥夺条件:线程以获得资源,在未使用完之前,不能强行剥夺
- 循环等待条件:若干线程之间形成一种头尾相接的循环等待资源关系
Lock锁
从JDK5.0 开始,Java提供了更强大的线程同步机制–通过显示定义同步锁对象来实现同步。同步锁使用Lock对象充当
ReentrantLock类实现了Lock
package com.ybl.syn;
import java.util.concurrent.locks.ReentrantLock;
public class TestLock {
public static void main(String[] args) {
TestLock2 a= new TestLock2();
new Thread(a,"A").start();
new Thread(a,"B").start();
new Thread(a,"C").start();
}
}
class TestLock2 implements Runnable{
int ticketNums=1000;
//定义 lock锁
private ReentrantLock lock =new ReentrantLock();
@Override
public void run() {
while (true){
try {
lock.lock(); //显示的加锁
if(ticketNums>0){
System.out.println(Thread.currentThread().getName()+"---"+ticketNums--);
}else{
break;
}
}finally {
lock.unlock();
}
}
}
}
Lock锁和synchronized对比
线程协作 --生产者消费者
问题描述
解决方式一
管程法
package com.ybl.pc;
//测试 生产者消费者问题--->利用缓冲区解决 管程法
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 container;
public Product(SynContainer container) {
this.container = container;
}
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println("生产了"+i+"只鸡");
container.push(new Chicken(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+"只鸡");
}
}
}
class Chicken{
int id; //产品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();
}
}
//如果可以消费
count--;
Chicken chicken=chickens[count];
//吃完了,通知生产者生成
this.notifyAll();
return chicken;
}
}
解决方式二
信号灯法—通过一个标志位flag来解决
线程池
package com.ybl;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class TestPool {
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());
}
}
pool-1-thread-1
pool-1-thread-2
pool-1-thread-4
pool-1-thread-3
Process finished with exit code 0
IDEA Tips
- 1000.for 可以直接输出for循环1000次的结构