多线程
gitee仓库md文件 有图片
(学自【狂神说Java】多线程详解_哔哩哔哩 (゜-゜)つロ 干杯~-bilibili)
三种创建方式
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zO3atrDi-1607432309812)(多线程.assets/image-20201002164759732.png)]
Thread
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fboULBCM-1607432309814)(多线程.assets/image-20201002165844736.png)]
package com.lrq.demo01;
/**
* @author liaor
*/
//创建线程方式一:继承Thread类,重写run()方法,调用start开启线程
//总结:注意,线程开启不一定立即执行,由CPU调度执行
public class TestThread01 extends Thread{
@Override
public void run(){
//run方法线程体
for (int i = 0; i < 20; i++) {
System.out.println("run" + i);
}
}
public static void main(String[] args) {
//main线程,主线程
//创建一个线程对象
TestThread01 testThread01 = new TestThread01();
//调用一个线程对象
testThread01.start();
for (int i = 0; i < 20; i++) {
System.out.println("main" + i);
}
}
}
package com.lrq.demo01;
import org.apache.commons.io.FileUtils;
import java.io.File;
import java.io.IOException;
import java.net.URL;
//练习Thread,实现多线程同步下载图片
public class TestThread02 extends Thread{
private String url;
private String name;
public TestThread02(String url, String name){
this.url = url;
this.name = name;
}
@Override
public void run(){
WebDownloder webDownloder = new WebDownloder();
webDownloder.downloader(url,name);
System.out.println(name + "下载成功");
}
public static void main(String[] args) {
TestThread02 t1 = new TestThread02("https://csdnimg.cn/cdn/content-toolbar/nationalDay-white.gif", "1.gif");
TestThread02 t2 = new TestThread02("https://csdnimg.cn/cdn/content-toolbar/nationalDay-white.gif", "2.gif");
TestThread02 t3 = new TestThread02("https://csdnimg.cn/cdn/content-toolbar/nationalDay-white.gif", "3.gif");
TestThread02 t4 = new TestThread02("https://csdnimg.cn/cdn/content-toolbar/nationalDay-white.gif", "4.gif");
t1.start();
t2.start();
t3.start();
t4.start();
}
}
class WebDownloder{
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
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rCMzTfpY-1607432309816)(多线程.assets/image-20201002184204418.png)]
package com.lrq.demo01;
//创建线程方式二:实现Runnable接口,重写run()方法,执行线程需要丢入Runnable接口实现类。调用start开启线程
public class TestRunnable01 implements Runnable{
@Override
public void run() {
//run方法线程体
for (int i = 0; i < 20; i++) {
System.out.println("run" + i);
}
}
public static void main(String[] args) {
//创建Runnable接口的实现类对象
TestRunnable01 testRunnable01 = new TestRunnable01();
//创建线程对象,通过线程对象来开启我们的线程,代理
Thread thread = new Thread(testRunnable01);
thread.start();
for (int i = 0; i < 20; i++) {
System.out.println("main" + i);
}
}
}
package com.lrq.demo01;
//多个线程同时操作同一个对象 买火车票的例子
//多个线程操作同一个资源的情况下,线程不安全,数据紊乱
public class TestRunnable02 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) {
TestRunnable02 ticket = new TestRunnable02();
new Thread(ticket,"A").start();
new Thread(ticket,"D").start();
new Thread(ticket,"B").start();
}
}
package com.lrq.demo01;
//模拟龟兔赛跑
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==90){
try {
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
boolean b = gameOver(i);
//如果比赛结束了 停止程序
if (b){
break;
}
System.out.println(Thread.currentThread().getName()+"-->跑了"+i+"步");
}
}
//判断是否完成比赛
public 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
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9VjIRsSD-1607432309818)(多线程.assets/image-20201002191406173.png)]
package com.lrq.demo02;
import com.lrq.demo01.TestThread02;
import org.apache.commons.io.FileUtils;
import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.util.concurrent.*;
//线程创建方法三:实现Callable接口
/*
Callable的好处
1。可以定义返回值
2.可以抛出异常
*/
public class TestCallable01 implements Callable<Boolean> {
private String url;
private String name;
public TestCallable01(String url, String name){
this.url = url;
this.name = name;
}
@Override
public Boolean call(){
WebDownloder webDownloder = new WebDownloder();
webDownloder.downloader(url,name);
System.out.println(name + "下载成功");
return true;
}
public static void main(String[] args) throws ExecutionException, InterruptedException {
TestCallable01 t1 = new TestCallable01("https://csdnimg.cn/cdn/content-toolbar/nationalDay-white.gif", "1.gif");
TestCallable01 t2 = new TestCallable01("https://csdnimg.cn/cdn/content-toolbar/nationalDay-white.gif", "2.gif");
TestCallable01 t3 = new TestCallable01("https://csdnimg.cn/cdn/content-toolbar/nationalDay-white.gif", "3.gif");
TestCallable01 t4 = new TestCallable01("https://csdnimg.cn/cdn/content-toolbar/nationalDay-white.gif", "4.gif");
//创建执行服务
ExecutorService ser = Executors.newFixedThreadPool(3);
//提交执行
Future<Boolean> r1 = ser.submit(t1);
Future<Boolean> r2 = ser.submit(t2);
Future<Boolean> r3 = ser.submit(t3);
Future<Boolean> r4 = ser.submit(t4);
//获取结果
Boolean rr1 = r1.get();
Boolean rr2 = r2.get();
Boolean rr3 = r3.get();
Boolean rr4 = r4.get();
//关闭服务
ser.shutdownNow();
}
}
class WebDownloder{
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.lrq.daili;
/*
静态代理模式总结
真实对象和代理对象都要实现同一个接口
代理对象要代理真实角色
好处
代理对象可以做很多真实对象做不了的事情
真实对象专注做自己的事情
*/
public class StaticProxy {
public static void main(String[] args) {
new Thread(()-> System.out.println("str")).start();
new WeddingCompany(new You()).happyMarry();
/*WeddingCompany weddingCompany = new WeddingCompany(new You());
weddingCompany.happyMarry();*/
}
}
interface Marry{
void happyMarry();
}
class You implements Marry{
@Override
public void happyMarry() {
System.out.println("happyMarry");
}
}
class WeddingCompany implements Marry{
//代理谁--》真实目标角色
private Marry target;
public WeddingCompany(Marry target) {
this.target = target;
}
@Override
public void happyMarry() {
after();
this.target.happyMarry();
before();
}
private void after(){
System.out.println("after");
}
private void before(){
System.out.println("before");
}
}
Lamda表达式
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tVtVknBz-1607432309820)(多线程.assets/image-20201002194345900.png)]
new Thread(()-> System.out.println("多线程学习,")).start();
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Ndk7z9Lq-1607432309821)(多线程.assets/image-20201002214615151.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lmFNY3Ho-1607432309822)(多线程.assets/image-20201002214823246.png)]
package com.lrq.lambda;
/**
* @author liaor
推导lamda
*/
public class TestLambda01 {
//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");
}
}
package com.lrq.lambda;
import java.util.function.Consumer;
public class TestLamdba02 {
public static void main(String[] args) {
ILove love = new Love();
love.love(2);
love = (a)->System.out.println("i love2 " +a);
love.love(1);
/*
总结:
lamdba表达式只能有一行代码的情况下才能简化成为一行,如果有多行,那么就用代码块包裹。
前提是接口为函数式接口
多个参数也可以去掉参数类型,要去掉就都去掉,必须加上括号*/
}
}
interface ILove{
void love(int a);
}
class Love implements ILove{
@Override
public void love(int a) {
System.out.println("i love "+a);
}
}
线程
线程状态
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sUi8AcrP-1607432309824)(多线程.assets/image-20201004100939850.png)]
线程方法
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gFWnsSSX-1607432309825)(多线程.assets/image-20201004101103892.png)]
停止线程(Stop)
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-547R3L9V-1607432309827)(多线程.assets/image-20201004101322108.png)]
package com.lrq.state;
/*测试stop
1.建议线程正常停止-->利用次数,不建议死循环。
2.建议使用标志位-->设置一个标志位
3.不要使用stop或者destory等过时或者jdk不建议使用的方法
*/
public class TestStop implements Runnable{
//1.设置一个标志位
private boolean flag = true;
@Override
public void run() {
int i = 0;
while (flag){
System.out.println("run..."+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++) {
System.out.println("main"+i);
if (i==900){
//调用stop方法切换标志位,让线程停止
testStop.stop();
System.out.println("线程停止了");
}
}
}
}
线程休眠(Sleep模拟网络延时:放大问题的发生性)
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lsYSqRgM-1607432309829)(多线程.assets/image-20201004102413848.png)]
package com.lrq.state;
import java.text.SimpleDateFormat;
import java.util.Date;
//模拟倒计时
public class TestSleep2 {
public static void main(String[] args) {
/* try {
tenDown();
} catch (InterruptedException e) {
e.printStackTrace();
}*/
//打印当前系统时间
Date date = new Date(System.currentTimeMillis());//获取系统当前时间
while (true){
try {
Thread.sleep(1000);
System.out.println(new SimpleDateFormat("HH:mm:ss").format(date));
date = new Date(System.currentTimeMillis());//更新当前时间
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public static void tenDown() throws InterruptedException {
int num = 10;
while (true){
Thread.sleep(1000);
System.out.println(num--);
if (num<0){
break;
}
}
}
}
线程礼让(Yield)
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ACq2gI71-1607432309830)(多线程.assets/image-20201004103538177.png)]
package com.lrq.state;
/*
* 测试礼让线程
* 礼让不一定成功,看CPU*/
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{
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+":start");
Thread.yield();//礼让
System.out.println(Thread.currentThread().getName()+":stop");
}
}
线程强制执行(join)
package com.lrq.state;
//测试join方法
public class TestJoin implements Runnable{
@Override
public void run() {
for (int i = 0; i < 1000; 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 < 500; i++) {
if (i==200){
thread.join();
}
System.out.println("main"+i);
}
}
}
线程状态观测
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1loao1A8-1607432309832)(多线程.assets/image-20201004190601256.png)]
package com.lrq.state;
//观察线程的状态
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);//NEW
//观察启动后
thread.start();//启动线程
state = thread.getState();
System.out.println(state);//RUN
while (state != Thread.State.TERMINATED){
//只要线程不终止,就一直输出状态
Thread.sleep(100);
state = thread.getState();//更新线程状态
System.out.println(state);//输出状态
}
}
}
线程优先级(priority)
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sK5LMPai-1607432309834)(多线程.assets/image-20201004191552539.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-aKaYhnVl-1607432309835)(多线程.assets/image-20201004192442828.png)]
package com.lrq.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();
t2.setPriority(1);
t2.start();
t3.setPriority(4);
t3.start();
t4.setPriority(Thread.MAX_PRIORITY);//MAX_PRIORITY=10
t4.start();
/*t5.setPriority(-1);
t5.start();
//<1&>10会报错
t6.setPriority(11);
t6.start();*/
}
}
class MyPriority implements Runnable{
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());
}
}
守护(daemon)线程
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xwkGbCoc-1607432309836)(多线程.assets/image-20201004192640427.png)]
package com.lrq.state;
//测试守护线程
public class TestDaemon {
public static void main(String[] args) {
A a = new A();
B b = new B();
Thread thread = new Thread(a);
thread.setDaemon(true);//默认是false表示用户线程,正常的线程都是用户线程
thread.start();//启动A线程
new Thread(b).start();//启动b线程
}
}
//A
class A implements Runnable{
@Override
public void run() {
while (true) {
System.out.println("A");
}
}
}
//B
class B implements Runnable{
@Override
public void run() {
for (int i = 0; i < 1000; i++) {
System.out.println("B:"+i);
}
System.out.println("B stop");
}
}
线程同步
多个线程操作同一个资源
并发(同一个对象被多个线程同时操作)
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-57AVSFe2-1607432309837)(多线程.assets/image-20201004193952853.png)]
形成条件:队列+锁
不安全案例
package com.lrq.syn;
//不安全的取钱 两个人去银行取钱,账号
public class UnsafeBank {
public static void main(String[] args) {
Account account= new Account(100,"A");
Drawing d1=new Drawing(account,50,"a");
Drawing d2=new Drawing(account,100,"b");
d1.start();
d2.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()+"钱不够了");
}
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//卡内余额 = 余额 - 你取的钱
account.money = account.money- drawingMoney;
//你手里的钱
nowMoney = nowMoney + drawingMoney;
System.out.println(account.name+"余额为:"+account.money);
//this.getName()= Thread.currentThread().getName()
System.out.println(this.getName()+"手里的钱"+nowMoney);
}
}
package com.lrq.syn;
//不安全的买票
public class UnsafeBuyTicket {
public static void main(String[] args) {
ButTicket station = new ButTicket();
new Thread(station,"A").start();
new Thread(station,"B").start();
new Thread(station,"C").start();
}
}
class ButTicket 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(100);
//买票
System.out.println(Thread.currentThread().getName()+"拿到"+ticketNums--);
}
}
package com.lrq.syn;
import com.sun.glass.ui.Size;
import java.util.ArrayList;
//线程不安全的集合
public class UnsafeList {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
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());
}
}
同步方法
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dCBrDX79-1607432309838)(多线程.assets/image-20201007223703357.png)]
弊端
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wwY9MHpD-1607432309839)(多线程.assets/image-20201007223950089.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ANB7FQxV-1607432309840)(多线程.assets/image-20201007224439967.png)]
死锁
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vBQE1OGr-1607432309841)(多线程.assets/image-20201007225506902.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MqbXYM5o-1607432309842)(多线程.assets/image-20201007230901399.png)]
package com.lrq.lock;
//死锁:多个线程互相抱着对方需要的资源,形成僵持
public class DeadLock {
public static void main(String[] args) {
Makeup m1 = new Makeup(0, "m1");
Makeup m2 = new Makeup(1, "m2");
m1.start();
m2.start();
}
}
//资源A
class A{
}
//资源B
class B{
}
class Makeup extends Thread{
//需要的资源只有一份,用static保证只有一份
static A a = new A();
static B b = new B();
int choice;//选择
String name;//需要资源的人
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 (a){//获得a的锁
System.out.println(this.name+"获得a的锁");
Thread.sleep(1000);
synchronized (b){//一秒钟后获得b的锁
System.out.println(this.name+"获得b的锁");
}
}
}else {
synchronized (b){//获得b的锁
System.out.println(this.name+"获得b的锁");
Thread.sleep(2000);
synchronized (a){//二秒钟后获得b的锁
System.out.println(this.name+"获得a的锁");
}
}
}
}
}
Lock(锁)
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MMOH404H-1607432309843)(多线程.assets/image-20201008154702238.png)]
package com.lrq.lock;
import java.security.interfaces.ECKey;
import java.util.concurrent.locks.ReentrantLock;
//测试lock锁
public class TestLock {
public static void main(String[] args) {
TestLock2 testLock2 = new TestLock2();
new Thread(testLock2).start();
new Thread(testLock2).start();
new Thread(testLock2).start();
}
}
class TestLock2 implements Runnable{
int ticketNums = 10;
// 定义lock锁
private final ReentrantLock lock = new ReentrantLock();
@Override
public void run() {
while (true){
lock.lock();
try {
//加锁
if (ticketNums>0){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(ticketNums--);
}else {
break;
}
} finally {
lock.unlock();
// 解锁
}
}
}
}
synchronized与lock的对比
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CT5BYSZx-1607432309844)(D:%5C%E5%AD%A6%E4%B9%A0%5C%E8%AE%B0%E5%BD%95%5C%E5%A4%9A%E7%BA%BF%E7%A8%8B.assets%5Cimage-20201208192506456.png)]
线程通讯
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-y5albpWj-1607432309846)(D:%5C%E5%AD%A6%E4%B9%A0%5C%E8%AE%B0%E5%BD%95%5C%E5%A4%9A%E7%BA%BF%E7%A8%8B.assets%5Cimage-20201208193106322.png)]
分析
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-G2xG0wf3-1607432309847)(D:%5C%E5%AD%A6%E4%B9%A0%5C%E8%AE%B0%E5%BD%95%5C%E5%A4%9A%E7%BA%BF%E7%A8%8B.assets%5Cimage-20201208193207276.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AfWiu8lg-1607432309848)(D:%5C%E5%AD%A6%E4%B9%A0%5C%E8%AE%B0%E5%BD%95%5C%E5%A4%9A%E7%BA%BF%E7%A8%8B.assets%5Cimage-20201208193220058.png)]
解决方式1
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-O3xdIKSb-1607432309849)(D:%5C%E5%AD%A6%E4%B9%A0%5C%E8%AE%B0%E5%BD%95%5C%E5%A4%9A%E7%BA%BF%E7%A8%8B.assets%5Cimage-20201208193403657.png)]
package com.lrq.lock;
/**测时:生产者消费者模型--》利用缓冲区解决:管程法
*
* 生产者 消费者 产品 缓冲区
* @author : lrq
* @Title :
* @date : 2020-12-08 19:36
*/
public class TestPC {
public static void main(String[] args) {
SynContainer synContainer = new SynContainer();
new Productor(synContainer).start();
new Consumer(synContainer).start();
}
}
/**
* 生产者
*/
class Productor extends Thread{
SynContainer container;
public Productor(SynContainer container) {
this.container = container;
}
//生产
@Override
public void run() {
for (int i = 0; i < 100; i++) {
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 = 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;
}
}
解决方式2
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lsefxEjO-1607432309850)(D:%5C%E5%AD%A6%E4%B9%A0%5C%E8%AE%B0%E5%BD%95%5C%E5%A4%9A%E7%BA%BF%E7%A8%8B.assets%5Cimage-20201208193504413.png)]
package com.lrq.lock;
/**测试:生产者消费者模型--》利用缓冲区解决:管程法
*
* 生产者 消费者 产品 缓冲区
* @author : lrq
* @Title :
* @date : 2020-12-08 19:36
*/
public class TestPC {
public static void main(String[] args) {
SynContainer synContainer = new SynContainer();
new Productor(synContainer).start();
new Consumer(synContainer).start();
}
}
/**
* 生产者
*/
class Productor extends Thread{
SynContainer container;
public Productor(SynContainer container) {
this.container = container;
}
//生产
@Override
public void run() {
for (int i = 0; i < 100; i++) {
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 = 0; i < 100; i++) {
System.out.println("消费了-->"+container.pop().id+"只鸡");
}
}
}
/**
* 产品
*/
class Chicken{
int id;
//产品编号
public Chicken(int id){
this.id = id;
}
}
线程池
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pKKInIsH-1607432309852)(D:%5C%E5%AD%A6%E4%B9%A0%5C%E8%AE%B0%E5%BD%95%5C%E5%A4%9A%E7%BA%BF%E7%A8%8B.assets%5Cimage-20201208201514094.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-P31E5oSr-1607432309853)(D:%5C%E5%AD%A6%E4%B9%A0%5C%E8%AE%B0%E5%BD%95%5C%E5%A4%9A%E7%BA%BF%E7%A8%8B.assets%5Cimage-20201208201643859.png)]
package com.lrq.lock;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* @author : lrq
* @Title :测试线程池
* @date : 2020-12-08 20:17
*/
public class TestPool {
public static void main(String[] args) {
//1.创建服务,创建线程池
//newFixedThreadPool 参数为线程池大小
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() {
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName()+i);
}
}
}
总结
package com.lrq.lock;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* @author : lrq
* @Title :测试线程池
* @date : 2020-12-08 20:17
*/
public class TestPool {
public static void main(String[] args) {
//1.创建服务,创建线程池
//newFixedThreadPool 参数为线程池大小
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() {
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName()+i);
}
}
}
args) {
//1.创建服务,创建线程池
//newFixedThreadPool 参数为线程池大小
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() {
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName()+i);
}
}
}
总结
```java
package com.lrq.lock;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* @author : lrq
* @Title :测试线程池
* @date : 2020-12-08 20:17
*/
public class TestPool {
public static void main(String[] args) {
//1.创建服务,创建线程池
//newFixedThreadPool 参数为线程池大小
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() {
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName()+i);
}
}
}