Java基础二
1.多线程
01简介
-
多任务
-
举例子 边吃饭边玩儿手机、边开车边打电话、边上厕所边玩儿手机
- 看起来是多个任务在做,其实本质上我们的大脑在同一时间依旧只做了一件事情
-
-
进程
在操作系统中运行的程序就是进程 -
普通方法调用和多线程
-
Process和Thread
- 说起进程，就不得不说下
程序。程序是指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的概念。 - 而进程则是执行程序的一次执行过程，它是一个动态的概念。是系统资源分配的单位
- 通常在一个进程中可以包含若干个线程，当然一个进程中至少有一个线程，不然没有存在的意义。线程是CPU调度和执行的的单位。
- 说起进程，就不得不说下
注意:很多多线程是模拟出来的，真正的多线程是指有多个cpu，即多核，如服务器。如果是模拟出来的多线程，即在一个cpu的情况下，在同一个时间点，cpu只能执行一个代码，因为切换的很快，所以就有同时执行的错局。
- 核心
- 线程就是独立的执行路径;
- 在程序运行时，即使没有自己创建线程，后台也会有多个线程，如主线程，gc线程
- main()称之为主线程，为系统的入口，用于执行整个程序;
- 在一个进程中，如果开辟了多个线程，线程的运行由调度器安排调度，调度器是与操作系统紧密相关的，先后顺序是不能认为的干预的。
- 对同一份资源操作时，会存在资源抢夺的问题，需要加入并发控制;
- 线程会带来额外的开销，如cpu调度时间，并发控制开销。
- 每个线程在自己的工作内存交互，内存控制不当会造成数据不一致
02线程实现(重点)
三种创建方式
-
一、Thread class
- 创建方式:
- 自定义线程类继承Thread类
- 重写Run方法编写线程集成体
- 创建线程对象.调用start()方法启动线程
- 实例:
package com.buba.controller; public class TestThread1 extends Thread{ @Override public void run() { //run方法线程体 for (int i = 0; i < 20; i++) { System.out.println("我在看代码"+i); } } public static void main(String[] args) { //创建一个线程对象 TestThread1 testThread1 = new TestThread1(); //调用start()方法 开启线程 testThread1.start(); //主方法main线程 for (int i = 0; i < 20; i++) { System.out.println("我在学习多线程"+i); } } } - 总结: 注意,线程开启不一定立即执行,由CPU调度执行
- 创建方式:
-
二、Runnable接口
- 创建方式:
- 定义MyRunnable类实现Runnable接口
- 实现run方法编写线程执行体
- 创建线程对象.调用start()方法启动线程
- 实例
package com.buba.controller; public class TestThread2 implements Runnable{ @Override public void run() { //run方法线程体 for (int i = 0; i < 20; i++) { System.out.println("我在看代码"+i); } } public static void main(String[] args) { //创建Runnable接口的实现类对象 TestThread2 testThread2 = new TestThread2(); //创建线程对象 通过线程对象来开启我们的线程,代理 // Thread thread = new Thread(testThread2); // thread.start(); new Thread(testThread2).start(); //主方法main线程 for (int i = 0; i < 20; i++) { System.out.println("我在学习多线程"+i); } } }
-
三、Callable接口(了解)
- 实现Callable接口，需要返回值类型
- 重写call方法，需要抛出异常
- 创建目标对象
- 创建执行服务:ExecutorService ser = Executors.newFixedThreadPool(1);
- 提交执行:Future result1 = ser.submit(t1);
- 获取结果: boolean r1 = result1.get()
- 关闭服务: ser.shutdownNow();
继承Thread和实现Runnable接口对比:
| 继承Thread类 | 实现Runnable接口 |
|---|---|
| 子类继承Thread类具备多线程能力 | 实现接口Runnable具有多线程能力 |
| 启动线程:子类对象.start() | 启动线程:传入目标对象+Thread对象.start() |
不建议使用:避免OOP单继承局限性 | 推荐使用:避免单继承局限性,灵活方便,方便用一个对象被多个线程使用 |
静态代理模式
静态代理模式总结:
- 真实对象和代理对象都要实现同一接口
- 代理对象要代理真实角色
好处:
- 代理对象可以做很多真是对象做不了的事情
- 真实对象专注做自己的事情
package com.buba.controller;
public class StaticProxy {
public static void main(String[] args) {
new Thread( ()-> System.out.println("我爱你")).start();
new WeddingCompany(new You()).HappyMarry();
// You you = new You();//你要结婚
// WeddingCompany weddingCompany = new WeddingCompany(you);
// weddingCompany.HappyMarry();
}
}
interface Marry{
void HappyMarry();
}
//真实角色 你去结婚
class You 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("结婚之后收尾款");
}
}
线程状态
- 图解:
线程方法:
| 方法 | 说明 |
|---|---|
| setPriority(int newPriority) | 更改线程的优先级 |
| static void sleep(long millis) | 在指定的毫秒数内让当前正在执行的线程体休眠 |
| void join() | 等待该线程终止 |
| static void yield() | 暂停当前真正该执行的线程对象,并执行其他的线程 |
| void interrupt() | 中断线程,别用这个方式 |
| boolean idAlive() | 测试线程是否处于活动状态 |
线程停止
- 1.建议线程正常停止,利用次数,不建议死循环
- 建议使用标志位 - - - 》 设置一个标志位
- 不要使用stop或destory等过时或JDK不建议使用的方法
package com.buba.controller;
import com.buba.pojo.Test;
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++) {
System.out.println("main"+i);
if (i==900){
//调用stop标志位 让线程停止
testStop.Stop();
System.out.println("线程该停止了");
}
}
}
}
线程休眠
- sleep (时间)指定当前线程阻塞的毫秒数;（1000ms = 1s）
- sleep存在异常InterruptedException;
- sleep时间达到后线程进入就绪状态;
- sleep可以模拟网络延时，倒计时等。
- 每一个对象都有一个锁，sleep不会释放锁;
package com.buba.controller.state;
import java.text.SimpleDateFormat;
import java.util.Date;
public class TestSleep2 {
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--);
if (num<=0){
break;
}
}
}
}
线程礼让
- 礼让线程,让当前正在执行的线程暂停,但不阻塞
- 将线程从运行状态转为就绪状态
让CPU重新调度,礼让不一定成功!看CPU心情
实例:
package com.buba.controller.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()+"线程开始执行");
Thread.yield();//礼让
System.out.println(Thread.currentThread().getName()+"线程停止执行");
}
}
输出结果①:
A线程线程开始执行
B线程线程开始执行
B线程线程停止执行
A线程线程停止执行
输出结果②:
A线程线程开始执行
A线程线程停止执行
B线程线程开始执行
B线程线程停止执行
线程强制执行Join
- Join合并线程,待此线程执行完成后,再执行其他线程,其他线程阻塞
- 可以想象成插队
实例:
package com.buba.controller.state;
//测试Join方法 //可以想象成插队
public class TestJoin implements Runnable{
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("mian"+i);
}
}
@Override
public void run() {
for (int i = 0; i < 1000; i++) {
System.out.println("线程VIP来了"+i);
}
}
}
部分输出结果截图:
观察线程的状态
实例:
package com.buba.controller.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); //输出状态
}
}
}
线程优先级
- Java提供了一个线程调度器来监控程序中启动后进入就绪状态的所有线程,线程调度器按照优先级来决定应该调度哪个线程来执行
- 线程的优先级用数字来表述,范围1~10.
- Thread.MIN_PROIORITY = 1;
- Thread.MAX_PROIORITY = 10;
- Thread.NORM_PROIORITY = 5;(默认)
- 具有较高优先级的线程对程序更重要，并且应该在低优先级的线程之前分配处理器资源。但是，线程优先级不能保证线程执行的顺序，而且非常依赖于平台(CPU)。
- 使用以下方式改变或获取优先级
- getPriority.setPriority(int xxx)
实例:
package com.buba.controller.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();
t6.setPriority(11);
t6.start();
}
}
class MyPriority implements Runnable{
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());
}
}
守护线程
- 线程分为守护线程和用户线程
- 虚拟机必须确保用户线程执行完毕
- 虚拟机不用等待守护线程执行完毕
- 如:后台记录操作日志,监控内存,垃圾回收等待…
实例:
package com.buba.controller.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 God implements Runnable{
@Override
public void run() {
while (true){
System.out.println("上帝保佑着你");
}
}
}
//你
class You implements Runnable{
@Override
public void run() {
for (int i = 0; i < 36500; i++) {
System.out.println("你一生都开心的活着");
}
System.out.println("======goodbye world!========");
}
}
03线程同步(重点)
线程同步: 多个线程操作同一个资源
- 并发:同一个对象被多个线程同时操作
- 现实生活中,我们会遇到”同一个资源,多个人都想使用”的问题，比如,食堂排队打饭﹐每个人都想吃饭﹐最天然的解决办法就是﹐排队一个个来.
- 处理多线程问题时,多个线程访问同一个对象，并且某些线程还想修改这个对象.这时候我们就需要线程同步﹒线程同步其实就是一种等待机制,多个需要同时访问此对象的线程进入这个对象的等待池形成队列,等待前面线程使用完毕，下一个线程再使用
- 线程不安全三大案例
- 案例一:
package com.buba.controller.Thread.syn; //不安全的买票 //线程不安全 有负数 public class UnsafeBuyTicket { public static void main(String[] args) { BuyTicket station = new BuyTicket(); new Thread(station,"小明").start(); new Thread(station,"小张").start(); new Thread(station,"可恶的黄牛党").start(); } } class BuyTicket 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.buba.controller.Thread.syn; //不安全的线程 //两个人去银行取钱,同一个账户 public class UnsafeBack { public static void main(String[] args) { //账户 Account account = new Account(100,"结婚基金"); Drawing you = new Drawing(account,50,"小张"); Drawing youGirl = new Drawing(account,100,"小丽"); you.start(); youGirl.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; } //sleep可以放大问题的发生性 try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } //卡内余额 = 余额 - 取的钱 account.money = account.money - drawingMoney; //你手里的钱 = 你钱包里的钱 + 你取得钱 nowMoney = nowMoney + drawingMoney; System.out.println(account.name+"余额为:"+account.money); //Thread.currentThread().getName()等价于this.getName() System.out.println(this.getName()+"手里的钱:"+nowMoney); } } - 案例三:
package com.buba.controller.Thread.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(()->{ list.add(Thread.currentThread().getName()); }).start(); } //方法问题的发生性 try { Thread.sleep(500); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(list.size()); } }
- 由于同一进程的多个线程共享同一块存储空间，在带来方便的同时,也带来了访问冲突问题﹐为了保证数据在方法中被访问时的正确性﹐在访问时加入
锁机制synchronized，当一个线程获得对象的排它锁﹐独占资源﹐其他线程必须等待，使用后释放锁即可.存在以下问题:- 一个线程持有锁会导致其他所有需要此锁的线程挂起;
- 在多线程竞争下﹐加锁,释放锁会导致比较多的上下文切换和调度延时,引起性能问题;
- 如果一个优先级高的线程等待一个优先级低的线程释放锁会导致优先级倒置，引起性能问题．
同步方法以及同步块
同步方法
- 由于我们可以通过private关键字来保证数据对象只能被方法访问﹐所以我们只需要针对方法提出一套机制,这套机制就是synchronized 关键字，它包括两种用法:synchronized方法和synchronized 块.
同步方法:public synchronized void method(int args){} - synchronized方法控制对“对象”的访问,每个对象对应一把锁，每个synchronized方法都必须获得调用该方法的对象的锁才能执行﹐否则线程会阻塞，方法一旦执行﹐就独占该锁，直到该方法返回才释放锁﹐后面被阻塞的线程才能获得这个锁,继续执行
缺陷:若将一个大的方法申明为synchronized将会影响效率 - 同步方法弊端: 方法里面需要修改的内容才需要锁,锁的太多浪费资源\
同步块
- synchronized
(Obj){} Obj称之为"同步监视器"- Obj可以是任何对象,但是推荐使用共享资源作为同步监视器
- 同步方法中无需指定同步监视器﹐因为同步方法的同步监视器就是this，就是这个对象本身﹐或者是class
- 同步监视器的执行过程
- 第一个线程访问﹐锁定同步监视器﹐执行其中代码
- 第二个线程访问﹐发现同步监视器被锁定，无法访问．
- 第一个线程访问完毕,解锁同步监视器．
- 第二个线程访问,发现同步监视器没有锁﹐然后锁定并访问
死锁
- 多个线程各自占有一些共享资源﹐并且互相等待其他线程占有的资源才能运行﹐而导致两个或者多个线程都在等待对方释放资源﹐都停止执行的情形﹒某一个同步块同时拥有“两个以上对象的锁”时﹐就可能会发生“死锁”的问题﹒
- 死锁避免方法
- 产生死锁的四种方法:
- 互斥条件:一个资源每次只能被一个进程使用。
- 请求与保持条件:一个进程因请求资源而阻塞时，对已获得的资源保持不放。
- 不剥夺条件:进程已获得的资源，在末使用完之前，不能强行剥夺。
- 循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系。
- 上面列出了死锁的四个必要条件，我们只要想办法破其中的任意一个或多个条件就可以避免死锁发生
- 产生死锁的四种方法:
- 实例
package com.buba.controller.Thread; //死锁:多个线程互相抱着对方需要的资源,然后形成僵持 public class DeadLoCK { public static void main(String[] args) { MakeUp g1 = new MakeUp(0,"灰姑凉"); MakeUp g2 = new MakeUp(1,"白雪公主"); g1.start(); g2.start(); } } //口红 class Lipstick{ } //镜子 class Mirror{ } class MakeUp extends Thread{ //需要的资源只有一份儿 用static来保证只有一份儿资源 static Lipstick lipstick = new Lipstick(); static Mirror mirror = new Mirror(); int choose;//选择 String girlName;//使用化妆品的人 MakeUp(int choose,String girlName){ this.choose = choose; this.girlName = girlName; } @Override public void run() { try { makeUp(); } catch (InterruptedException e) { e.printStackTrace(); } } //化妆 互相持有对方的锁,就是需要拿到对方的资源 private void makeUp() throws InterruptedException { if (choose == 0 ){ synchronized (lipstick){ //获得口红的锁 System.out.println(this.girlName+"获得口红的锁"); Thread.sleep(1000); } synchronized (mirror){ //一秒之后想获得镜子 System.out.println(this.girlName+"一秒钟后获得镜子的锁"); } }else{ synchronized (mirror){ //获得镜子的锁 System.out.println(this.girlName+"获得镜子的锁"); Thread.sleep(2000); } synchronized (lipstick){ //两秒之后想获得口红 System.out.println(this.girlName+"两秒钟后获得口红的锁"); } } } }
Lock锁
- 从JDK 5.0开始，Java提供了更强大的线程同步机制——通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当
- java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象
- ReentrantLock类实现了Lock，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock(
可重入锁)，可以显式加锁、释放锁。 - 实例
package com.buba.controller.Thread; 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 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(); //如果同步代码有异常,要将unlock()写入finally语句块 } } } }
synchronized 与Lock的对比
| synchronized | Lock |
|---|---|
| 隐式锁,出了作用域自动释放 | 显式锁,手动开启和关闭锁(别忘记关闭锁) |
| 有代码块锁和方法锁 | 只有代码块锁 |
- 使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性(提供更多的子类)
- 优先使用顺序
- Lock >同步代码块（已经进入了方法体，分配了相应资源)>同步方法（在方法体之外)
04线程通信问题
前言:
- 应用场景:生产者和消费者问题
- 假设仓库中只能存放一件产品，生产者将生产出来的产品放入仓库﹐消费者将仓库中产品取走消费.
- 如果仓库中没有产品，则生产者将产品放入仓库，否则停止生产并等待，直到仓库中的产品被消费者取走为止．
- 如果仓库中放有产品,则消费者可以将产品取走消费﹐否则停止消费并等待,直到仓库中再次放入产品为止.
这是一个线程同步问题，生产者和消费者共享同一个资源，并且生产者和消费者之间相互依赖，互为条件．- 对于生产者，没有生产产品之前，要通知消费者等待﹒而生产了产品之后﹐又需要马上通知消费者消费
- 对于消费者﹐在消费之后,要通知生产者已经结束消费﹐需要生产新的产品以供消费.
- 在生产者消费者问题中,仅有synchronized是不够的
- synchronized可阻止并发更新同一个共享资源，实现了同步
- synchronized不能用来实现不同线程之间的消息传递(通信)
解决方式
-
一、并发协作模型“生产者/消费者模式”—>管程法
- 生产者∶负责生产数据的模块(可能是方法﹐对象﹐线程,进程);
- 消费者︰负责处理数据的模块(可能是方法﹐对象,线程,进程);
- 缓冲区:消费者不能直接使用生产者的数据，他们之间有个“缓冲区
生产者将生产好的数据放入缓冲区，消费者从缓冲区拿出数据
-
二、并发协作模型“生产者/消费者模式”—>信号灯法
-
三、…
实例:
- 管程法:
package com.buba.controller.gaoji; //测试:生产者消费者模型 利用缓冲区解决:管程法 //生产者 消费者 产品 缓冲区 public class TestPC { public static void main(String[] args) { SynContainer container = new SynContainer(); new Producter(container).start(); new Consumer(container).start(); } } //生产者 class Producter extends Thread{ SynContainer container; public Producter(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){ //如果容器满了 就需要等待消费者消费 如果没有满就需要丢入产品 while (count == chickens.length) { try { //通知消费者消费 生产者等待 this.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } //如果没有满就需要丢入产品 chickens[count] = chicken; count++; this.notifyAll(); //可以通知消费者消费了 } //消费者消费产品 public synchronized Chicken pop() { //判断能否消费 while (count == 0) { try { //等待生产者生产,消费者等待 this.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } //如果可以消费 count--; Chicken chicken = chickens[count]; this.notifyAll(); //吃完了通知生产者生产 return chicken; } } - 信号灯法:
package com.buba.controller.gaoji; //测试生产者消费者问题2,信号灯法,标志位解决 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; } @Override public void run() { for (int i = 0; i < 20; i++) { if (i%2==0){ this.tv.play("快乐大本营播放中"); }else { this.tv.play("抖音:记录美好生活"); } } } } //消费者-->观众 class Watcher extends Thread{ TV tv; public Watcher(TV tv){ this.tv = tv; } @Override public void run() { for (int i = 0; i < 20; i++) { tv.watch(); } } } //产品-->节目 class TV { //演员表演的时候 观众等待 T //观众观看的时候,演员等待 F 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.notify();//通知唤醒 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; } }
05高级主体
使用线程池
- 背景:经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大。
- 思路:提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用。类似生活中的公共交通工具。
- 好处:
- 提高响应速度（减少了创建新线程的时间)
- 降低资源消耗（重复利用线程池中线程，不需要每次都创建)
- 便于线程管理(…)
- corePoolSize:核心池的大小
- maximumPoolSize:最大线程数
- keepAliveTime:线程没有任务时最多保持多长时间后会终止
- JDK 5.0起提供了线程池相关API:
ExecutorService和Executorsk - ExecutorService:真正的线程池接口。常见子类ThreadPoolEjecutor
实例:
class TestPool {
public static void main(String[] args) {
//1.创建服务,创建线程池
//newFixedThreadPool参数为线程池大小
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());
}
}
1144
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
