多线程
进程是执行程序的一次执行过程,是一个动态的概念。是系统资源分配的单位。
进程可以包含一个或多个线程(至少有一个)。线程是CPU调度和执行的单位。
实现方式:
- 继承Thread类,并重写run()方法
- 实现Runnable接口,实现run()方法(最重要)
- 实现Callable接口,线程结束后有返回值,但依赖线程池
Thread
创建方法一:
Thread
1.自定义线程类继承Thread类
2.重写**run()**方法,编写线程执行体
3.创建线程对象,调用**start()**方法启动线程
public class TestThread extends Thread {
@Override
public void run() {
// run方法线程体
System.out.println("进入线程TestThread");
}
// main线程,主线程
public static void main(String[] args) {
// 创建一个线程
TestThread thread = new TestThread();
// 调用start()方法开启线程
thread.start();
// 两条线程同时进行
}
}
线程开启,不一定立即执行,由CPU调度执行
例子,下载图片
// 多线程同步下载图片
public class Test02 extends Thread{
// 网络图片地址
private String url;
// 保存的文件名
private String name;
public Test02(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) {
// 创建线程对象
Test02 t1 = new Test02("url","name");
Test02 t2 = new Test02("url","name");
Test02 t3 = new Test02("url","name");
// 调用start()执行
t1.start();
t2.start();
t3.start();
}
}
// 下载器
class WebDownloader {
// 下载方法
public void downloader(String url,String name){
FileUtils.copURLToFile(new URL(url),new File(name));
}
}
Runnable
1.自定义Runnable类实现Runable接口
2.实现**run()**方法,编写线程执行体
3.创建线程对象,线程对象中丢入Runnable接口实现类对象,调用start()方法启动线程
public class TestRunnable implements Runnable{
@Override
public void run() {
// run方法线程体
System.out.println("run方法线程体");
}
public static void main(String[] args) {
// 创建runnable接口的实现类对象
TestRunnable runnable = new TestRunnable();
// 创建线程对象,通过线程对象来开启我们的线程,代理
// Thread thread = new Thread(runnable);
// thread.start();
// 多个代理(简写)
// new Thread(runnable).start();
new Thread(runnable,"1").start();
new Thread(runnable,"2").start();
new Thread(runnable,"3").start();
}
}
对比:
继承Thread类
- 子类继承Thread类具备多线程能力
- 启动线程:子类对象.start()
- 不建议使用:避免OOP单继承局限性
实现Runnable接口
- 实现接口Runnable具有多线程能力
- 启动线程:传入目标对象+Thread对象.start()
- 推荐使用:避免单继承局限性,灵活方便,方便同时一个对象被多个线程使用
// 多个线程操作同个对象(火车票)
// 多个线程操作同一个资源时,线程不安全,数据紊乱
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();
}
// 获取当前线程name
String name = Thread.currentThread().getName();
System.out.println(name+"拿到了第"+ticketNums--+"张票");
}
}
public static void main(String[] args) {
TestRunnable02 runnable02 = new TestRunnable02();
// 同时开启线程
new Thread(runnable02,"小明").start();
new Thread(runnable02,"老师").start();
new Thread(runnable02,"黄牛").start();
}
}
龟兔赛跑
// 模拟龟兔赛跑
public class TestRace implements Runnable{
// 胜利者
private static String winner;
@Override
public void run() {
for (int i = 0; i <= 100; i++) {
// 模拟兔子休息
if (Thread.currentThread().getName().equals("兔子") && 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;
} else if (steps>=100){
winner = Thread.currentThread().getName();
System.out.println("winner is "+winner);
return true;
} else {
return false;
}
}
public static void main(String[] args) {
TestRace race = new TestRace();
new Thread(race,"兔子").start();
new Thread(race,"乌龟").start();
}
}
Callable接口
1.实现Callable接口,需要返回值类型
2.重写call方法,需要抛出异常
3.创建目标对象
4.创建执行服务:ExecutorService ser = Executors.newFixedThreadPool(1);
5.提交执行:Future result1 = ser.submint(t1);
6.获取结果:boolean r1 = result1.get();
7.关闭服务:ser.shutdownNow();
// 实现Callable
public class TestCallable implements Callable<Boolean> {
private String name = "";
public TestCallable(String name) {
this.name = name;
}
// 可定义返回值
@Override
public Boolean call() throws Exception {
// 线程执行体
TestMethod method = new TestMethod();
method.testMethod(name);
return true;
}
// 主程序
public static void main(String[] args) throws Exception{
TestCallable callable1 = new TestCallable("1");
TestCallable callable2 = new TestCallable("2");
TestCallable callable3 = new TestCallable("3");
// Callable主要
// 创建执行服务
ExecutorService ser = Executors.newFixedThreadPool(3);
// 提交执行
Future<Boolean> r1 = ser.submit(callable1);
Future<Boolean> r2 = ser.submit(callable2);
Future<Boolean> r3 = ser.submit(callable3);
// 获取结果
Boolean rs1 = r1.get();
Boolean rs2 = r2.get();
Boolean rs3 = r3.get();
// 关闭服务
ser.shutdown();
System.out.println(rs1);
System.out.println(rs2);
System.out.println(rs3);
}
}
class TestMethod {
public void testMethod(String name) {
System.out.println("name:"+name);
}
}
FutureTask
// 使用FutureTask
FutureTask<Boolean> futureTask = new FutureTask<Boolean>(callable1);
// 与runnable类似,创建线程对象,并将futureTask对象丢入
new Thread(futureTask).start();
// 获取返回值
Boolean aBoolean = futureTask.get();
System.out.println(aBoolean);
好处:
- 可以抛出异常
- 可以定义返回值
静态代理
静态代理为线程底部原理
总结:
- 真实对象和代理对象都要实现同一个接口
- 代理对象要代理真实角色
好处:
- 代理对象可以做真实对象做不了的事
- 真实对象只需要专注做自己的事
// 静态代理模式
public class StaticProxy {
public static void main(String[] args) {
// 真实角色
You you = new You();
// 真实角色
TestRunnable runnable = new TestRunnable();
new Thread(runnable).start();
// 原理相同
new WeddingCompany(you).HappyMarry();
// 传入真实角色you
// WeddingCompany company = new WeddingCompany(you);
// company.HappyMarry();
}
}
interface Marry {
void HappyMarry();
}
// 真实角色,you,实现Marry
class You implements Marry {
@Override
public void HappyMarry() {
// you只需要做的
System.out.println("marry......");
}
}
// 代理角色,company ,来帮助you,实现Marry
class WeddingCompany implements Marry {
// 代理对象--》代理真实角色
private Marry target;
// 创建时,需传入真实角色
public WeddingCompany(Marry target) {
this.target = target;
}
@Override
public void HappyMarry() {
before(); // 代理对象做的
this.target.HappyMarry(); // 这就是真实对象you,调用you重写的方法(线程重写的run方法)
after(); // 代理对象做的
}
private void before() {
System.out.println("before marry");
}
private void after() {
System.out.println("pay...");
}
}
Lambda表达式
(jdk1.8)
为什么要用lambda表达式:避免匿名内部类过多,去掉无意义代码,更简洁
函数式接口:接口中,只有一个抽象方法。
可以通过lambda表达式来创建函数式接口的对象。
所以只有函数式接口,才能用Lambda
推导Lambda:
// 推导Lambda
public class TestLamda {
// 3.静态内部类
static class Like2 implements ILike {
@Override
public void lamda() {
System.out.println("I like Lamda2");
}
}
public static void main(String[] args) {
ILike iLike1 = new Like();
iLike1.lamda();
ILike iLike2 = new Like2();
iLike2.lamda();
// 4.局部内部类
class Like3 implements ILike {
@Override
public void lamda() {
System.out.println("I like Lamda3");
}
}
ILike iLike3 = new Like3();
iLike3.lamda();
// 5.匿名内部类,没有类的名称,必须借助接口或父类
ILike iLike4 = new ILike(){
// 没有声明类,直接重写接口里的方法
@Override
public void lamda() {
System.out.println("I like Lamda4");
}
};
iLike4.lamda();
// 6.用lamda简化
ILike iLike5 = ()->{
System.out.println("I like Lamda5");
};
iLike5.lamda();
}
}
// 1.定义一个函数式接口
interface ILike {
void lamda();
}
// 2.实现类
class Like implements ILike {
@Override
public void lamda() {
System.out.println("I like Lamda");
}
}
// 有参数时,a为参数
ILike iLike5 = (int a)->{
System.out.println("I like Lamda5");
};
// 简化参数类型,多个参数也可以去掉,要去掉,全去掉
ILike iLike5 = (a)->{
System.out.println("I like Lamda5");
};
// 简化括号
ILike iLike5 = a->{
System.out.println("I like Lamda5");
};
// 简化花括号,因为只有一行,所以能简化花括号
ILike iLike5 = a-> System.out.println("I like Lamda5");
总结:
因为只有一行,所以能简化花括号
只有函数式接口,才能用Lambda
多个参数也可以去掉,要去掉,全去掉
Runnable也是函数式接口,可以用Lambda简化
// 简化runnable的实现类和重写run方法,返回Runnable对象
Runnable runnable1 = ()-> {
System.out.println("run!!!");
};
// 创建线程对象,并丢入runnable对象,start()
new Thread(runnable1).start();
线程状态
方法 | 描述 |
---|---|
setPriority(int newPriority) | 更改线程的优先级 |
static void sleep(long millis) | 让正在执行的线程休眠millis毫秒 |
void join() | 待该线程终止,再执行其他线程(插队) |
static void yield() | 暂停当前正在执行的线程,并执行其他线程 |
void interrupt() | 中断线程(不要用) |
boolean isAlive() | 测试线程是否处于活动状态 |
停止线程
不推荐:stop()、destroy()
推荐:让程序自己停下来,利用次数、不建议死循环
建议:使用标志位,flag = false;终止线程
// 测试停止
public class TestStop implements Runnable{
// 1.设置标志位
private boolean flag = true;
@Override
public void run() {
int i = 0;
while (flag) {
System.out.println("running...");
}
}
// 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 < 10; i++) {
System.out.println("main"+i);
if (i == 9) {
System.out.println("stop");
// 调用方法,修改标志位停止线程
testStop.stop();
}
}
}
}
线程休眠
sleep(long time)方法
time:线程休眠毫秒数
sleep时间达到后,进入就绪状态
每一个对象都一个锁,sleep不会释放锁
模拟网络延时,放大问题的发生性
// 倒计时模拟
public class TestCountDown {
public static void main(String[] args) throws InterruptedException {
// 打印当前系统时间
Date startTime = new Date(System.currentTimeMillis());
while (true) {
Thread.sleep(1000);
System.out.println(new SimpleDateFormat("HH:mm:ss").format(startTime));
// 更新时间
startTime = new Date(System.currentTimeMillis());
}
//TestCountDown.tenDown();
}
public static void tenDown() throws InterruptedException {
int num = 10;
while (true) {
Thread.sleep(1000);
System.out.println(num--);
if (num<=0) {
break;
}
}
}
}
线程礼让
yield()
暂停线程,但不阻塞
让线程从运行状态转为就绪状态
让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()+"线程开始停止");
}
}
线程强制执行
Join() 合并线程,待此线程执行完成后,再执行其他线程,其他线程阻塞(插队)
不建议用
// 测试join方法,插队
public class TestJoin implements Runnable{
@Override
public void run() {
for (int i = 0; i < 5; i++) {
System.out.println("vip");
}
}
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 < 20; i++) {
if (i == 10) {
thread.join();// 插队,先执行vip,vip执行完,再继续主线程
}
System.out.println("main"+i);
}
}
}
线程状态观察
五大状态
NEW:新建状态,尚未启动的
RUNNABLE:就绪状态,调用start()方法后,位于可运行线程池中,等待cpu调度
RUNNING:运行状态,获得了cpu时间片,执行代码
BLOCKED:阻塞状态,被阻塞等待监视器锁定
DEAD:死亡状态,执行完或因异常退出,结束生命周期,死亡后,不能再次启动
Thread.State
- NEW:一个尚未启动的线程的状态。也称之为初始状态、开始状态。
- RUNNABLE:一个可以运行的线程的状态,就绪状态、运行状态。
- BLOCKED:一个线程因为等待监视锁而被阻塞的状态。也称之为阻塞状态。
- WAITING:一个正在等待的线程的状态。也称之为等待状态,无限期等待。
- TIMED_WAITING:一个在限定时间内等待的线程的状态。也称之为限时等待状态。
- TERMINATED:一个完全运行完成的线程的状态。也称之为终止状态、结束状态。
// 测试线程状态
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(); //RUNNABLE
System.out.println(state);
// 只要不终止,就一直输出状态
while (state != Thread.State.TERMINATED) {
Thread.sleep(100);
state = thread.getState();// 更新状态
System.out.println(state);
}
//死亡后,不能再次启动
//thread.start();
}
}
线程的优先级
线程调度器按照优先级决定哪个线程先执行,大部分优先级高的先执行,
高优先级的不一定先于低优先级的线程执行。(跟CPU的调度有关)
优先级低只是获得调度的概率低,并不是优先级低就不会被调用。
范围1-10;
Thread.MAX_PRIORITY = 10;
Thread.MIN_PRIORITY = 1;
Thread.NORM_PRIORITY = 5;(默认的)
方法:getPriority()、setPriority(int newPriority)
优先级的setPriority 放在start()之前
// 测试线程优先级
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);
t1.start();
t2.setPriority(1);
t2.start();
t3.setPriority(4);
t3.start();
t4.setPriority(Thread.NORM_PRIORITY);//MAX_PRIORITY=10
t4.start();
}
}
class MyPriority implements Runnable {
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());
}
}
守护线程(daemon)
线程分为:用户线程和守护线程
虚拟机(gc)必须确保用户线程执行完毕
虚拟机(gc)不用等待守护线程执行完毕
// 测试守护线程
public class TestDaemon {
public static void main(String[] args) {
God god = new God();
People people = new People();
Thread thread = new Thread(god);
thread.setDaemon(true);// 默认是false,表示默认是用户线程
thread.start();//守护线程启动
new Thread(people).start();// 用户线程启动
}
}
// god
class God implements Runnable{
@Override
public void run() {
while (true) {
System.out.println("bless");
}
}
}
// People
class People implements Runnable{
@Override
public void run() {
for (int i = 0; i < 36500; i++) {
System.out.println("living");
}
System.out.println("goodbye");
}
}
线程同步
多个线程操作同一个对象,解决线程不同步
线程同步其实是一种等待机制,排队
队列和锁
线程同步的条件:队列+锁
锁机制(synchronized)
问题:
效率降低
如果一个优先级高的线程等待一个优先级低的线程释放锁,会导致优先级倒置,引起性能问题。
同步方法和同步块
同步方法
synchronized方法控制对"对象"的访问,每个对象对应一把锁,每个synchronized方法必须获得调用该方法对象的锁才能执行,否则会阻塞。(厕所排队,锁门)
缺点:一个大的方法声明为synchronized将会影响效率,锁太多了
方法里面需要修改的内容才需要锁,锁太多,浪费资源
// 不安全的买票
// 加synchronized 就安全了
public class Unsafe01 {
public static void main(String[] args) {
BuyTicket buyTicket = new BuyTicket();
new Thread(buyTicket,"a").start();
new Thread(buyTicket,"b").start();
new Thread(buyTicket,"黄牛").start();
}
}
class BuyTicket implements Runnable{
//票
private int ticketNums = 10;
boolean flag = true;// 外部停止方式
@Override
public void run() {
// 买票
while (flag){
buy();
}
}
// synchronized同步方法,锁的是this
private synchronized void buy(){
// 判断是否有票
if (ticketNums<=0){
flag = false;
return;
}
// 模拟延时
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 买票
System.out.println(Thread.currentThread().getName()+"拿到"+ticketNums--);
}
}
同步块
常用
synchronized(Obj){}
Obj称之为 同步监视器
- Obj可以是任何对象,但是推荐使用共享资源(需修改)作为同步监视器
// 不安全的取钱
// 两个人去银行取钱
public class Unsafe02 {
public static void main(String[] args) {
// 账户
Account stack = new Account(100, "stack");
// 两个人同时取钱
Drawing you = new Drawing(stack, 50,"你");
Drawing gf = new Drawing(stack, 100,"gf");
you.start();
gf.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;
}
// 模拟延时,放大问题的发生性
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);
}
}
}
CopyOnWriteArrayList
// 测试JUC 安全类型的集合
public class TestJUC {
public static void main(String[] args) {
CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<String>();
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());
}
}
死锁
多个线程都在等待对方释放资源,都停止执行
如果一个同步代码块,同时拥有”两个以上对象的锁“,就可能发送”死锁“的问题。
产生死锁的四个必要条件:
- 互斥条件:一个资源每次只能被一个进程使用
- 请求与保持条件:一个进程因请求资源而阻塞,对已获得的资源不放
- 不剥夺条件:进程已获得的资源,在未使用之前,不能强行剥夺
- 循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系
只要避免一个或多个,就可以避免死锁
// 死锁:多个线程互相抱着对方需要的资源,然后互相僵持
public class TestDeadLock {
public static void main(String[] args) {
Makeup g1 = new Makeup(0,"g1");
Makeup g2 = new Makeup(1,"g2");
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 girl;// 化妆的人
public Makeup(int choice, String girl) {
this.choice = choice;
this.girl = girl;
}
@Override
public void run() {
makeup();
}
// 化妆,互相持有对方的锁,就是需要拿到对方的资源
private void makeup(){
if (choice==0){
//获得口红的锁
synchronized (lipstick){
System.out.println(this.girl+"获得口红的锁");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
// 不能同时拥有两个锁
// 1s后获得镜子的锁
synchronized (mirror){
System.out.println(this.girl+"获得镜子的锁");
}
} else {
//获得镜子的锁
synchronized (mirror){
System.out.println(this.girl+"获得镜子的锁");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
// 不能同时拥有两个锁
// 1s后获得口红的锁
synchronized (lipstick){
System.out.println(this.girl+"获得口红的锁");
}
}
}
}
Lock(锁)
显式同步锁
ReentrantLock类实现了Lock,(可重入锁)
可显式加锁、解锁
只能锁代码块
性能更好
优先使用顺序:
lock>同步块>同步方法
//测试lock锁
public class TestLock {
public static void main(String[] args) {
TestLock2 buyTicket = new TestLock2();
new Thread(buyTicket,"a").start();
new Thread(buyTicket,"b").start();
new Thread(buyTicket,"黄牛").start();
}
}
class TestLock2 implements Runnable{
//票
private int ticketNums = 10;
// 定义lock锁
private final 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(Thread.currentThread().getName()+"拿到"+ticketNums--);
} else {
break;
}
} finally {
// 解锁
lock.unlock();
}
}
}
}
// 定义lock锁
private final ReentrantLock lock = new ReentrantLock();
lock.lock();
try{
// 保证线程安全的代码
} finally {
lock.unlock();
//如果同步代码有异常,写入finally
}
线程协作
生产者消费者模式
线程通信
这是一个线程同步问题,生产者和消费者共享同一个资源,并且生产者和消费者之间互相依赖
- 生产者,没产品通知消费者等待,有产品通知消费者去消费
- 消费者,消费之后,要通知生产者已经结束消费,需要生产新的产品以供消费。
方法 | 描述 |
---|---|
wait() | 表示线程等待,直到其他线程通知,与sleep不同,会释放锁 |
wait(long timeout) | 指定等待的毫秒 |
notify() | 唤醒一个处于等待状态的线程 |
notifyAll() | 唤醒同一个对象上所有调用wait()方法的线程,优先级高的线程,优先 |
解决方式1
管程法:生产者将生产好的数据放入缓冲区,消费者从缓冲区中拿出数据
// 测试:生产者消费者模型---管程法:利用缓冲区解决
//生产者,消费者,产品,缓冲区
public class TestPC {
public static void main(String[] args) {
SynContainer container = new SynContainer();
new Producer(container).start();
new Consumers(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 Consumers extends Thread{
SynContainer container;
public Consumers(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
信号灯法:标志为true,使消费者等待,为false,通知消费者消费
// 生产者消费者问题2:信号灯法:标志位解决
public class TestPC02 {
public static void main(String[] args) {
TV tv = new TV();
new Player(tv).start();
new Audience(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 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 {
// 演员表演的时候,观众等待 T
// 观众观看,演员等待 F
// 表演的界面
String voice;
boolean flag = true;//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:线程没有任务时,最多保持多久后终止
ExecutorService
线程池接口。常见子类ThreadPoolExecutor
- void execute(Runnable command): 执行,没有返回值;一般用来执行Runnable
- Future submit(Callable task): 执行任务,有返回值,一般用来执行Callable
- void shutdown(): 关闭连接池
Executors
工具类、线程池的工厂类,创建并返回不同类型的线程池
// 测试线程池
public class TestPool {
public static void main(String[] args) {
// 1.创建服务,创建线程池
// 参数为线程池大小
ExecutorService service = Executors.newFixedThreadPool(2);
// 执行runnable线程
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());
}
}
中断
下列哪些情况下会导致线程中断或停止运行( )
# 正确答案: A B 你的答案: A D (错误)
A InterruptedException异常被捕获
B 线程调用了wait方法
C 当前线程创建了一个新的线程
D 高优先级线程进入就绪状态
解析:
-
A 一般通过interrupt方法中断线程
-
B 线程使用了wait()方法,会强行打断当前操作,进入阻塞(暂停)状态,然后需要notify方法或notifyAll方法才能使线程进入就绪状态
-
C 创建新的线程不会抢占时间片,只有当前线程用完,其他线程才有资格拿到时间片去执行
-
D 权限更高只是说明他获得CPU被执行的几率更大
- 在抢先制系统中,当前线程运行时,如果有较高优先级的线程准备就绪,则正在运行的低优先级线程将会被挂起,转到较高优先级线程运行,高优先级线程完成后,会转到原低优先级线程
(3) 线程间的通知和唤醒
-
Object类 这些方法都是本地方法,且为final方法,无法被重写。
- wait()
- notify()
- notfiyAll()
-
Condition接口 实现线程间协作更加高效和安全,推荐
- await()
- signal()
- signalAll()
(4) join()
t.join() : 等待t线程执行完再继续执行
t.join(1000) : 等待t线程,等待的时间是1000ms
synchronized
- 修饰非静态方法时,锁的是this对象
- 修饰静态方法时,锁的是class对象