吹爆 狂神老师 的 B站教程
Java 多线程
线程简介
-
一个进程,通常可以包含若干个线程,线程是 CPU 调度和执行的单位。
-
线程就是独立的执行路径;
-
在程序运行时,即使没有自己创建线程,后台也会有多个线程,如主线程,gc 线程;
-
main() 为主线程,即系统的入口,用于执行整个程序;
-
在一个进程中,如果开辟了多个线程,线程的运行由调度器安排调度,调度器是与操作系统紧密相关的,先后顺序是不能人为干预的;
-
对同一份资源操作时,会存在资源抢夺的问题,需要加入并发控制;
-
线程会带来额外的开销,如 CPU 调度时间,并发控制开销;
-
每个线程只能在自己的工作内存中交互,内存控制不当会造成数据不一致。
线程实现(重点)
普通方法调用和多线程
三种实现方式
-
Thread class —— 继承 Thread 类(重点)
-
Runnable 接口 —— 实现 Runnable 接口(重点)
-
Callable 接口 —— 实现 Callable 接口(了解)
Thread 实现(不建议使用,避免OOP单继承局限性)
-
自定义线程类继承 Thread 类
-
重写 run() 方法,编写线程执行体
-
创建线程对象,调用 start() 方法启动线程
示例
package Thread;
// 创建线程方式1:继承 Thread 类,重写 run() 方法,调用 start 开启线程
// 总结:注意,线程开启不一定立即执行,由 CPU 调度执行
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) {
// main 线程,主线程
// 创建一个线程对象
TestThread1 testThread1 = new TestThread1();
// 调用 start 方法开启线程
testThread1.start();
for (int i = 0; i < 20; i++) {
System.out.println("我在学习多线程----" + i);
}
}
}
Runnable 实现 (推荐使用Runnable对象,避免 Java 单继承的局限性,方便同一个对象被多个线程使用)
-
定义 MyRunnable 类实现 Runnable 接口
-
实现 run() 方法,编写线程执行体
-
创建线程代理类对象,调用 start() 方法启动线程
示例
package Thread;
// 创建线程方式2:实现 Runnable 接口,重写 run 方法,执行线程需要丢入 runnable 接口实现类
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 接口的实现类对象
TestThread1 testThread2 = new TestThread1();
// 创建线程对象,通过线程对象来开启我们的线程,代理
new Thread(testThread2).start();
// 线程体
for (int i = 0; i < 20; i++) {
System.out.println("我在学习多线程----" + i);
}
}
}
示例:抢票
package Thread;
// 多个线程同时操作一个对象
// 抢票
public class TestThread3 implements Runnable{
// 票数
private int ticketNums = 10;
// 重写 run 方法
@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) {
TestThread3 ticket = new TestThread3();
// 创建代理线程对象,调用 start 方法启动线程
new Thread(ticket, "小明").start();
new Thread(ticket, "老师").start();
new Thread(ticket, "黄牛党").start();
}
}
示例:龟兔赛跑
package Thread;
// 模拟龟兔赛跑
public class Race implements Runnable{
private static String winner;
@Override
public void run() {
for (int i = 1; i <= 100; i++) {
// 模拟兔兔睡觉
if (Thread.currentThread().getName() == "兔兔" && i%10 == 0) {
try {
Thread.sleep(1);
} 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();
// 创建代理线程对象,调用 start 方法启动线程
new Thread(race, "龟龟").start();
new Thread(race, "兔兔").start();
}
}
Callable 接口(了解即可)
- 实现 Callable 接口,需要返回值类型
- 重写 call 方法,需要抛出异常
- 创建目标对象
- 创建执行服务:ExecutorService ser = Executors.newFixedThreadPool(1);
- 提交执行:Future result1 = ser.submit(t1);
- 获取结果:boolean r1 = result1.get()
- 关闭服务:ser.shutdownNow();
Lamda 表达式(用起来很爽,但最好别用)
这里没学暂时跳过了
线程状态
停止线程
- 不推荐使用 JDK 提供的 stop()、destroy() 方法。【已废弃】
- 推荐线程自己停下来
- 建议使用一个标志位终止变量,当 flag = false,则终止线程运行。
示例
package Thread;
// 测试 stop
// 1.建议线程正常停止-->利用次数,不建立死循环
// 2.建议使用标志位
// 3.不要使用 stop 或者 destroy 等过时或者 JDK 不建议使用的方法
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(时间) 指定当前线程阻塞的毫秒数;
- sleep 存在异常 InterruptedException;
- sleep 时间结束后线程进入就绪状态;
- sleep 可以模拟网络延时,倒计时等;
- 每一个对象都有一个锁,sleep 不会释放锁;
示例 1
package Thread;
// 模拟网络延时:放大问题的发生性
// 线程的不安全性
public class TestSleep implements Runnable{
// 票数
private int ticketNums = 10;
// 重写 run 方法
@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) {
TestSleep ticket = new TestSleep();
// 创建代理线程对象,调用 start 方法启动线程
new Thread(ticket, "小明").start();
new Thread(ticket, "老师").start();
new Thread(ticket, "黄牛党").start();
}
}
示例 2 - 获取系统每秒时间
package Thread;
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) throws InterruptedException {
// tenDown();
// }
public static void main(String[] args) throws InterruptedException {
// 获取系统当前时间
Date startime = new Date(System.currentTimeMillis());
while (true) {
Thread.sleep(1000);
System.out.println(new SimpleDateFormat("HH:mm:ss").format(startime));
startime = new Date(System.currentTimeMillis()); // 更新时间
}
}
}
线程礼让
- 礼让线程,让当前正在执行的线程暂停,但不阻塞
- 将线程从运行状态转为就绪状态
- 让 CPU 重新调度,礼让不一定成功!看 CPU 心情 hhh
示例 感觉这个例子不是很好
package Thread;
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() + "线程停止执行");
}
}
Join 线程插队
- join 合并线程,待此线程执行完成后,再执行其他线程,其他线程阻塞
- 可以想象成插队
示例
package Thread;
// 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 {
// vip 线程
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);
}
}
}
线程状态监测
- Thread.State
示例
package Thread;
// 观察测试线程的状态
public class TestState implements Runnable{
@Override
public void run() {
for (int i = 0; i < 5; i++) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("///");
}
public static void main(String[] args) throws InterruptedException {
TestState testState = new TestState();
Thread thread = new Thread(testState);
// 观察状态
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();
}
}
线程优先级
- Java 提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程,线程调度器按照优先级决定应该调度哪个线程来执行。
- 线程的优先级用数字表示,范围从1~10
- 使用以下方式改变或获取优先级
- getPriority()、setPriority(int n);
示例
package Thread;
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(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());
}
}
守护(daemon)线程
- 线程分为用户线程和守护线程
- 虚拟机必须确保用户线程执行完毕
- 虚拟机不用等待守护线程执行完毕
- 如,后台记录操作日志,监控内存,垃圾回收(gc 线程)等
示例 - 人生不过三万天
package Thread;
// 测试守护线程
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! ");
}
}
线程同步(重点)
多个线程操作同一个资源。
并发:同一个对象被多个线程操作。
线程同步其实就是一种等待机制,多个需要同时访问此对象的线程进入这个对象的等待池形成队列,等待前面的线程使用完毕,下一个线程再使用。
由于同一进程的多个线程共享同一块存储空间,在带来方便的同时,也带来了访问冲突的问题,为了保证数据在方法中被访问时的正确性,在访问时加入 锁机制 synchronized,当一个线程获得对象的排它锁,独占资源时,其他线程必须等待,使用后释放锁即可。但存在一下问题:
- 一个线程持有锁会导致其他所有需要此锁的线程挂起;
- 在多线程竞争下,加锁,释放锁会导致比较多的上下文切换 和 调度延时,引起性能问题;
- 如果一个优先级高的线程等待一个优先级低的线程释放锁 会导致优先级倒置,引起性能问题。
同步方法
由于我们可以通过 private 关键字来保证数据对象只能被方法访问,所以我们只需要针对方法提出一套机制,这套机制就是 synchronized 关键字,它包括两种用法:synchronized 方法和 synchronized 块。
同步方法:public synchronized void method(int args) {}
synchronized 方法控制对"对象"的访问,每个对象对应一把锁,每个 synchronized 方法都必须获得调用该方法的对象的锁才能执行,否则线程会阻塞,方法一旦执行,就独占该锁,直到该方法返回才释放锁,后面被阻塞的线程才能获得这个锁,继续执行。
缺陷:若将一个大的方法申明为 synchronized 将会影响效率
- 方法里面需要修改的内容才需要锁,锁的太多,浪费资源
同步块
-
同步块:synchronized(Obj) {}
-
Obj 称之为 同步监视器
- Obj 可以是任何对象,但是推荐使用共享资源作为同步监视器。
- 同步方法中无需指定同步监视器,因为同步方法的同步监视器就是 this,就是这个对象本身,或者是 class [反射中讲解]。
-
同步监视器的执行过程
- 第一个线程访问,锁定同步监视器,执行其中代码。
- 第二个线程访问,发现同步监视器被锁定,无法访问。
- 第一个线程访问完毕,解锁同步监视器。
- 第二个线程访问,发现同步监视器没有锁,然后锁定并访问。
示例 1
package Thread;
// 抢票
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 (true) {
try {
buy();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
// synchronized 同步方法,锁的是 this
private synchronized void buy() throws InterruptedException {
// 判断是否有票
if (ticketNums <= 0) {
flag = false;
return ;
}
// 模拟延时
Thread.sleep(100);
// 买票
System.out.println(Thread.currentThread().getName() + "拿到" + ticketNums--);
}
}
示例 2
package Thread;
// 不安全的取钱
// 两个人都去银行取钱
public class UnsafeBank {
public static void main(String[] args) {
Account account = new Account(1000, "结婚基金");
Drawing you = new Drawing(account, 50, "你");
Drawing girlfriend = new Drawing(account, 100, "女朋友");
you.start();
girlfriend.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 ;
}
// 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);
System.out.println(this.getName() + Thread.currentThread().getName() + "手里的钱:" + nowMoney);
}
}
}
示例 3
package Thread;
import java.util.ArrayList;
import java.util.List;
// 创建 List
// 线程不安全,去掉延迟后,仍然会有线程错误
public class UnsafeList {
public static void main(String[] args) throws InterruptedException {
List<String> list = new ArrayList<String>();
for (int i = 0; i < 10000; i++) {
new Thread(()->{
synchronized (list) {
list.add(Thread.currentThread().getName());
}
}).start();
}
Thread.sleep(3000);
System.out.println(list.size());
}
}
JUC 包举例
package Thread;
import java.util.concurrent.CopyOnWriteArrayList;
// 测试股 JUC 安全类型的集合
public class TestJUC {
public static void main(String[] args) throws InterruptedException {
CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<String>();
for (int i = 0; i < 10000; i++) {
new Thread(()-> {
list.add(Thread.currentThread().getName());
}).start();
}
Thread.sleep(3000);
System.out.println(list.size());
}
}
死锁
多个线程各自占有一些共享资源,并且互相等待其他线程占有的资源才能运行,而导致两个或者多个线程都在等待对方释放资源,都停止执行的情形,某一个同步块同时拥有”两个以上对象的锁“时,就可能会发生”死锁“的问题
示例
package 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 choice; // 选择
String girlName; // 女孩名
Makeup(int choice, String girlName) {
this.choice = choice;
this.girlName = girlName;
}
@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.girlName + "获得口红的锁");
Thread.sleep(1000);
synchronized (mirror) { // 一秒钟后想获得镜子
System.out.println(this.girlName + "获得镜子的锁");
}
}
// synchronized (mirror) { // 一秒钟后想获得镜子
// System.out.println(this.girlName + "获得镜子的锁");
// }
}
else {
synchronized (mirror) { // 获得镜子的锁
System.out.println(this.girlName + "获得镜子的锁");
Thread.sleep(1000);
synchronized (lipstick) { // 一秒钟后想获得口红
System.out.println(this.girlName + "获得口红的锁");
}
}
// synchronized (lipstick) { // 一秒钟后想获得口红
// System.out.println(this.girlName + "获得口红的锁");
// }
}
}
}
产生死锁的四个必要条件:
- 互斥条件:一个资源每次只能被一个进程使用
- 请求与保持条件:一个进程因请求资源而阻塞时,对已获得的资源保持不放
- 不剥夺条件:进程已获得的资源,在未使用完之前,不能强行剥夺
- 循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系
上面列出的死锁的四个必要条件,只要能打破其中的任意一个或多个条件就可以避免死锁的发生
Lock 锁
- 从 jdk5.0 开始,Java 提供了更强大的线程同步机制——通过显式定义同步锁对象来实现同步。同步锁使用 Lock 对象充当。
- java.util.concurrent.locks.Lock 接口是控制多个线程对共享资源进行访问的工具。
- ReentrantLock 类实现了 Lock,它拥有与 synchronized 相同的并发性和内存语义,在实现线程安全的控制中,比较常用的是 ReentrantLock,可以显式加锁、释放锁。
synchronized 与 lock 的对比
- Lock 是显式锁(手动开启和关闭锁,不能忘记关闭锁) synchronized 是隐式锁,出了作用域自动释放
- Lock 只有代码块锁,synchronized 有代码块锁和方法锁
- 使用 Lock 锁,JVM 将花费较少的时间来调度线程,性能更好。并且具有更好的扩展性(提供更多的子类)
- 优先使用顺序:
- Lock > 同步代码块(已经进入了方法体,分配了相应资源) > 同步方法(在方法体之外)
线程通信协作问题
Java 提供了几个方法解决了线程之间的通信问题
- wait():表示线程一直等待,直到其他线程通知,与 sleep 不同,会释放锁
- wait(long timeout):指定等待的毫秒数
- notify():唤醒一个处于等待状态的线程
- notifyAll():唤醒同一个对象上所有调用 wait() 方法的线程,优先级别高的线程优先调度
Note:均是 Object 类的方法,都只能在同步方法或者同步代码中使用,否则会抛出异常 IllegalMonitorStateException
生产者消费者问题
示例 - 缓冲区解决办法:管程法
package Thread;
// 生产者消费者问题-->利用缓冲区解决:管程法
import com.sun.corba.se.impl.orbutil.concurrent.Sync;
// 生产者、消费者、产品、缓冲区
public class TestPC {
public static void main(String[] args) {
SynContainer container = new SynContainer();
new Producer(container).start();
new Customer(container).start();
}
}
// 生产者
class Producer extends Thread {
SynContainer container;
public Producer(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 Customer extends Thread {
SynContainer container;
public Customer(SynContainer container) {
this.container = container;
}
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println("消费了" + i + "只鸡");
}
}
}
// 产品
class Chicken extends Thread {
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 Thread;
// 生产者消费者问题2:标志位解决,信号量法
public class TestPC2 {
public static void main(String[] args) {
TV tv = new TV();
new Actor(tv).start();
new Audience(tv).start();
}
}
// 生产者 --> 演员
class Actor extends Thread {
TV tv;
public Actor(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 Audience extends Thread {
TV tv;
public Audience(TV tv) {
this.tv = tv;
}
@Override
public 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) {
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("观看了:" + voice);
// 通知演员表演
this.notifyAll();
this.flag = !this.flag;
}
}
线程池
-
背景:经常创建和销毁、使用量特别大的资源,比如并发情况下的线程,对性能影响很大。
-
思路:提前创建好多个线程,放入线程池中,使用时直接获取,使用完放回池中。可以避免频繁创建销毁、实现重复利用。类似生活中的公共交通工具。
-
好处:
- 提高相应速度(减少了创建新线程的时间)
- 降低资源消耗(重复利用线程池中的线程,不需要每次都创建)
- 便于线程管理
- corePoolSize:核心池的大小
- maximumPoolSize:最大线程数
- keepAliveTime:线程没有任务时最多保持多长时间后会终止
-
JDK 5.0 起提供了线程池相关的 API:ExecutorService 和 Exectors
-
ExecutorService:真正的线程池接口。常见子类 ThreadPoolExecutor
- void execute (Runnable command):执行任务/命令,没有返回值,一般用来执行 Runnable
- Future submit(Callable task):执行任务,有返回值,一般用来执行 Callable
- void shutdown():关闭线程池
-
Executors:工具类、线程池的工厂类,用于创建并返回不同类型的线程池
示例 - 感觉这里的例子好简单,以后再深入学习吧,狂神领进门,修行看个人
package Thread;
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());
}
}
完结撒花
package Thread;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.FutureTask;
public class ThreadNew {
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 {
@Override
public void run() {
System.out.println("MyThread1");
}
}
// 2. 实现 Runnable 接口
class MyThread2 implements Runnable {
@Override
public void run() {
System.out.println("MyThread2");
}
}
// 3. 实现 Callable 接口
class MyThread3 implements Callable<Integer> {
@Override
public Integer call() throws Exception {
System.out.println("MyThread3");
return 100;
}
}
下一步 - Java 网络编程