整体参考
一、线程
1、多任务:
现实中太多这样同时做多件事情的例子了,看起来是多个任务都在做,其实本质上我们的大脑在同一时间依旧只做了一件事情。
2、多线程:
原来是一条路,慢慢因为车太多了,道路阻塞,效率极低。为了提高使用的效率,能够充分利用道路,于是加了多个车道。
3、程序、进程、线程
进程(process):在操作系统中运行的程序就是进程,比如QQ,播放器,游戏,IDE等
一个进程(Thread)可以有多个线程,如视频中有多个线程分别控制声音、图像、字幕等
4、Process与Thread
说起进程,就不得不说下程序。程序是指令和数据的有序集合,其本身没有任何运行的含义,是一个静态的概念。
而进程则是执行程序的依次执行过程,它是一个动态的概念。是系统资源分配的单位。
通常在一个进程中可以包含若干个线程,当然一个进程中至少有一个线程,不然没有存在的意义。线程是CPU调度和执行的单位。
程序是静态的,程序跑起来变成进程,进程里分为若干个线程,真正执行的是线程,进程知识系统资源分配的单位。
main是主线程。
注意:
很多多线程是模拟出来的,真正的多线程是指有多个cpu,即多核,如服务器。如果是模拟出来的多线程,即在一个cpu的情况下,在同一个时间点,cpu只能执行一个代码,因为切换的很快,所以就有同时执行的错局。
5、核心概念
- 线程就是独立的执行路径
- 在程序运行时,即使没有自己创建线程,后台也会有多个线程,比如主线程,GC线程
- main()称之为主线程,为系统的入口,用于执行整个程序
- 在一个进程中,如果开辟了多个线程,线程的运行是由调度器(cpu)安排调度的,调度器是与操作系统紧密相关的,先后顺序是不能人为干预的.
- 对同一份资源操作时,会存在资源抢夺的问题,需要加入并发控制。
- 线程会带来额外的开销,如CPU调度时间,并发控制开销
- 每个线程在自己的工作内存交互,内存控制不当会造成数据不一致
二、线程实现(重点)
2.1 线程创建
有以下三种方式Thread, Runnable, Callable
Thread实际就是实现了Runnable接口
1、继承Thread类
步骤:
自定义一个线程类继承Thread
类;
重写run()
方法,编写线程执行体;
创建线程对象,调用start()
方法启动线程。
具体代码如下:
//创建线程方式一:继承Thread类,重写run()方法,调用start开始线程
//总结;注意,线程开启不一定执行,由CPU调度执行
public class TestThread1 extends Thread{
@Override
public void run() {
//run()方法线程体
for (int i = 0; i < 200; i++) {
System.out.println("我在看代码---"+i);
}
}
public static void main(String[] args) {
//main线程,主线程
//创建一个线程对象
TestThread1 testThread1 = new TestThread1();
//调用start方法开启线程
testThread1.start();
for (int i = 0; i < 1000; i++) {
System.out.println("我在学习多线程---"+i);
}
}
}
调用start()那里不能写run()方法,因为如果是run()方法,程序执行的时候就是,先执行“我在看代码……”,执行完之后才执行main()方法中的“我在学习多线程……”,并不是想要的同步执行的多线程。
注意:线程开启不一定执行,由CPU调度执行
案例:下载图片
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;
}
//下载图片线程的集合体
public void run(){
WebDownLoader webDownLoader = new WebDownLoader();
webDownLoader.downloader(url,name);
System.out.println("下载的文件名:"+name);
}
public static void main(String[] args) {
TestThread2 t1 = new TestThread2("https://www.cup.edu.cn/images/2022-10/4d0ba385fbe44ed69c3f44ccb4b81b23.jpg", "1.jpg");
TestThread2 t2 = new TestThread2("https://www.cup.edu.cn/news/images/2022-10/a0923c114feb4770bef9627d1e698f0a.jpg","2.jpg");
TestThread2 t3 = new TestThread2("https://www.cup.edu.cn/images/2021-10/bcde29aad64842ac82fc8abcc32077b2.jpg","3.jpg");
t1.start();
t2.start();
t3.start();
}
}
//下载器
class WebDownLoader{
//下载方法
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方法出现问题");
}
}
}
以上代码执行出来的结果并不是先下载t1,然后t2,最后t3,而是随机下载。
2、实现Runnable接口
推荐使用Runnable对象,因为Java单继承的局限性
自定义一个线程类MyRunnable实现Runnable
接口
实现run()
方法,编写线程执行体
创建线程对象,调用start()
方法启动线程
//创建线程方式2:实现Runnable接口,重写run方法,执行线程需要丢入runnable接口实现类,调用start方法
public class TestThread3 implements Runnable{
@Override
public void run() {
//run方法线程体
for (int i = 0; i < 200; i++) {
System.out.println("我在看代码---"+i);
}
}
public static void main(String[] args) {
//①创建Runnable接口的实现类对象
TestThread3 testThread3 = new TestThread3();
//②创建线程对象,通过线程对象来开始我们的线程,代理
// Thread thread = new Thread(testThread3);
// thread.start();
new Thread(testThread3).start();
for (int i = 0; i < 1000; i++) {
System.out.println("我在学习多线程---"+i);
}
}
}
案例:使用实现Runnable接口的方式下载图片
import org.apache.commons.io.FileUtils;
import java.io.File;
import java.io.IOException;
import java.net.URL;
//练习Thread,实现多线程同步下载图片
public class TestThread2 implements Runnable{
private String url; //网络图片地址
private String name; //保存的文件名
public TestThread2(String url,String name){
this.url = url;
this.name = name;
}
//下载图片线程的集合体
public void run(){
WebDownLoader webDownLoader = new WebDownLoader();
webDownLoader.downloader(url,name);
System.out.println("下载的文件名:"+name);
}
public static void main(String[] args) {
TestThread2 t1 = new TestThread2("https://www.cup.edu.cn/images/2022-10/4d0ba385fbe44ed69c3f44ccb4b81b23.jpg", "1.jpg");
TestThread2 t2 = new TestThread2("https://www.cup.edu.cn/news/images/2022-10/a0923c114feb4770bef9627d1e698f0a.jpg","2.jpg");
TestThread2 t3 = new TestThread2("https://www.cup.edu.cn/images/2021-10/bcde29aad64842ac82fc8abcc32077b2.jpg","3.jpg");
new Thread(t1).start();
new Thread(t2).start();
new Thread(t3).start();
}
}
//下载器
class WebDownLoader{
//下载方法
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方法出现问题");
}
}
}
Thread和Runnable对比:
- 继承Thread类
- 子类继承THread类具备多线程能力
- 启动线程:子类对象.start();
- 不建议使用:避免OOP单继承局限性
- 实现Runnable接口
- 实现接口Runnable具有多线程能力
- 启动线程:传入目标对象+Thread对象.start()
- 推荐使用:避免单继承局限性,灵活方便,方便同一个对象被多个线程使用
案例:火车票
public class TestThread4 implements Runnable {
private int ticketNums = 10;
@Override
public void run() {
while (true) {
if (ticketNums <= 0) {
break;
}
//模拟延时
try {
Thread.sleep(200);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.println(Thread.currentThread().getName() + "-->拿到了第" + ticketNums-- + "票");
}
}
public static void main(String[] args) {
TestThread4 ticket = new TestThread4();
new Thread(ticket, "小明").start();
new Thread(ticket, "老师").start();
new Thread(ticket, "黄牛党").start();
}
}
两个人同时拿到第五张票,这是不对的。
出现问题:多个线程操作同一个资源的情况下,线程不安全,数据紊乱,出现并发问题。
案例:龟兔赛跑
//模拟龟兔赛跑
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(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();
new Thread(race,"兔子").start();
new Thread(race,"乌龟").start();
}
}
3、实现Callable接口(了解)
步骤:
实现Callable接口,需要返回值类型;
重写call方法,需要抛出异常;
创建目标对象;
创建执行服务:ExecutorService ser = Executors.newFixedThreadPool(1);
提交执行:Future result1 = ser.submit(t1);
获取结果:boolean r1 = result1.get()
关闭服务:ser.shutdownNow();
callable的好处:
可以定义返回值,可以抛出异常
2.2 静态代理
具体代码实现:
/**
* 静态代理:结婚案例
*/
public class Demo7_StaticProxy {
public static void main(String[] args) {
WeddingCompany weddingCompany = new WeddingCompany(new You());
weddingCompany.happyMarry();
}
}
//结婚接口
interface Marry {
void happyMarry();
}
//真实角色:你去结婚
class You implements Marry {
@Override
public void happyMarry() {
System.out.println("dd要结婚了,超开心");
}
}
//代理角色:帮助你结婚
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 after() {
System.out.println("结婚之后,收尾款");
}
private void before() {
System.out.println("结婚之前,布置现场");
}
}
//
结婚之前,布置现场
dd要结婚了,超开心
结婚之后,收尾款
静态代理模式总结:
真实对象和代理对象都要实现同一个接口;
代理对象要代理真实角色。
好处:
代理对象可以做很多真实对象做不了的事情;
真实对象专注做自己的事情。
2.3 Lambda表达式
- 避免匿名内部类定义过多
- 其实质属于函数式编程的概念
- 去掉了一堆没有意义的代码,只留下核心逻辑
(params)-> expression[表达式]
(params) -> statement[语句]
[(params)-> {statements}
a -> System.out.println("i like lamda-->"+a)
new Thread (()->System.out.println(“多线程学习。。。。”)).start();
理解Functional Interface (函数式接口) 是学习Java8 lamda表达式的关键.
函数式接口:任何接口,如果只包含唯一一个抽象方法,那么它就是一个函数式接口
public interface Runnable{
public abstract void run();
}
对于函数式接口,我们可以通过Lamda表达式来创建该接口的对象.
public class Demo12_Lamda3 {
public static void main(String[] args) {
//5.匿名内部类,没有类的名称,必须借助接口或者父类
ILike like = new ILike () {
@Override
public void lamda() {
System.out.println("I like lamda3");
}
};
like.lamda();
}
}
interface ILike{
void lambda();
}
简化之后:
public class Demo12_Lamda3 {
public static void main(String[] args) {
//6.Lambda简化
ILike like = () -> {
System.out.println("I like lamda3");
};
like.lamda();
}
}
interface ILike{
void lambda();
}
案例2:
public class Demo14_LamdaCase2 {
public static void main(String[] args) {
// 1.lamda
ILove love = (int a) -> {
System.out.println("I love you -->" + a);
};
// 2.lamda简化1.0
love = (a) -> {
System.out.println("I love you -->" + a);
};
// 3.lamda简化2.0
love = a -> {
System.out.println("I love you -->" + a);
};
// 3.lamda简化3.0
love = a -> System.out.println("I love you -->" + a);
/**总结:
* {}简略的条件是只能有一行代码,多行{}就不能简略了
* 前提是接口为函数式接口(只能有一个方法)
* 多个参数也可以去掉参数类型,要去掉就都去掉,必须加上()
*/
love.love(520);
}
}
interface ILove {
void love(int a);
}
总结:
- {}简略的条件是只能有一行代码,多行{}就不能简略了
- 前提是接口为函数式接口(只能有一个方法)
- 多个参数也可以去掉参数类型,要去掉就都去掉,不去掉就必须加上()
三、线程状态
3.1 五种状态
详细过程:
3.2 线程方法
@Deprecated是官方已经不推荐使用了
1、停止线程
1.建议线程正常停止—>利用次数,不建议死循环
2.建议使用一个标志位进行终止变量—>设置一个标志位(当flag=false,则终止线程运行)
3.不要使用stop或destory等过时或者jdk不建议使用的方法【已废弃】
具体代码如下:
//测试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......Thread"+i++);
}
}
//2.设置一个公开的方法停止线程,转换标志位
public void stop(){
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("线程停止了");
}
}
}
}
2、线程休眠 sleep()
- sleep(时间)指定当前线程阻塞的毫秒数;
- sleep存在异常InterruptedException;
- sleep时间达到后线程进入就绪状态;
- sleep可以模拟网络延时,倒计时等;
- 每一个对象都有一个锁,sleep不会释放锁。
1000ms = 1s
模拟网络延时:放大问题的发生性
案例一:模拟倒计时
package com.lxy.state;
//模拟倒计时
public class TestSleep2 {
public static void main(String[] args) {
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;
}
}
}
}
案例二:按秒打印当前时间
import java.text.SimpleDateFormat;
import java.util.Date;
public class TestSleep3 {
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();
}
}
}
}
3、线程礼让 yield()
- 礼让线程,让当前正在执行的线程暂停,但不阻塞
- 将线程从运行状态转为就绪状态
- 让cpu重新调度,礼让不一忘成功!看CPU心情
具体代码如下:
//测试礼让线程
//礼让不一定成功,看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线程开始执行
a线程停止执行
b线程停止执行
4、线程插队
- join合并线程,待此线程执行完成后,再执行其他线程,其他线程阻塞
- 可以想象成插队
具体代码为:
package com.lxy.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 < 50; i++) {
if (i==20){
thread.join();//插队
}
System.out.println("main "+i);
}
}
}
3.3 线程状态观测
具体观测代码如下:
package com.lxy.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);//输出状态
}
}
}
3.4 线程优先级 priority
具体代码如下:
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.MAX_PRIORITY);
t4.start();
}
}
class MyPriority implements Runnable{
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"--->"+Thread.currentThread().getPriority());
}
}
注意:
优先级低只是意味着获得调度的概率低,并不是优先级低就不会被调用了,这都是看CPU的调度;
优先级的设定建议在start()调度之前。
3.5 守护线程 daemon
- 线程分为用户线程和守护线程
- 虚拟机必须确保用户线程执行完毕
- 虚拟机不用等待守护线程执行完毕
- 如:后台记录操作日志,监控日志,垃圾回收等待……
具体实现如下:
package com.lxy.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("你一生都开心的活着");
}
}
}
四、线程同步(重点)
4.1 介绍
多个线程操作同一个资源
并发:同一个对象被多个线程同时操作
处理多线程问题时,多个线程访问同一个对象,并且某些线程还想修改这个对象这时候我们就需要线程同步。线程同步其实就是一种等待机制,多个需要同时访问此对象的线程进入这个对象的等待池形成队列,等待前面线程使用完毕,下一个线程再使用
实现同步需要队列和锁
线程同步
在这里举三个例子来展示线程的三大不安全
案例一:三个人抢10张票
案例二:两个人取钱
案例三:创建10000条线程
4.2 同步方法
具体实现如下(对买票机制进行修改):
package com.lxy.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 ticketsNums = 10;
boolean flag = true;
@Override
public void run() {
//买票
while (flag){
buy();
}
}
//synchronized同步的方法,锁的是this
public synchronized void buy() {
//判断是否有票
if (ticketsNums<=0){
flag = false;
return;
}
//模拟延时
try {
Thread.sleep(100);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
//买票
System.out.println(Thread.currentThread().getName()+"拿到"+ticketsNums--);
}
}
如果这个方法中有两块代码,A代码只读,B代码才是修改(修改的才需要加锁),如果全锁就会浪费资源。
所以需要同步块,也就是只锁需要锁的那部分。
4.3 同步块
具体实现如下(对取钱机制进行修改):
锁的是accout
package com.lxy.syn;
import java.applet.Applet;
//不安全的取钱
//两个人去银行取钱,账户
public class UnsafeBank {
public static void main(String[] args) {
//账户
Account account = new Account(100,"结婚基金");
Drawing you = new Drawing(account, 50, "你");
Drawing girlFriend = new Drawing(account, 100, "girlFriend");
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;
}
//取钱
@Override
public void run() {
synchronized (account){
//判断有没有钱
if (account.money-drawingMoney<0){
System.out.println(this.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(Thread.currentThread().getName()+"手里的钱"+nowMoney);
}
}
}
锁的对象就是变量的量,需要增删改的对象
具体实现如下(对创建10000条线程进行修改):
锁的是list
package com.lxy.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 < 10000; i++) {
new Thread(()->{
synchronized (list){
list.add(Thread.currentThread().getName());
}
}).start();
}
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(list.size());
}
}
JUC安全集合类型扩充(CopyOnWriteArrayList)
本身就是安全的,和上面的效果一样
import java.util.concurrent.CopyOnWriteArrayList;
//JUC安全类型集合
public class TestJUC {
public static void main(String[] args) {
CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();
for (int i = 0; i < 10000; i++) {
new Thread(()->{
list.add(Thread.currentThread().getName());
}).start();
}
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.println(list.size());
}
}
4.4 死锁
多个线程各自占有一些共享资源,并且互相等待其他线程占有的资源才能运行,而导致两个或者多个线程都在等待对方释放资源,都停止执行的情形。某一个同步块同时拥有“两个以上对象的锁”时,就可能会发生“死锁”的问题。
具体实现如下:
package demo;
//死锁,多个线程互相抱着对方需要的资源,然后形成僵持
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 Lipstick lipstick = new Lipstick();
static Mirror mirrror = 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) {
throw new RuntimeException(e);
}
}
//化妆,互相持有对方的锁,就是需要拿到对方的资源
private void makeup() throws InterruptedException {
if (choice == 0) {
synchronized (lipstick) {//获得口红的锁
System.out.println(this.girlName + "获得口红的锁");
Thread.sleep(1000);
synchronized (mirrror) { //一秒钟后想获得镜子
System.out.println(this.girlName + "获得镜子的锁");
}
}
} else {
synchronized (mirrror) { //获得镜子的锁
System.out.println(this.girlName + "获得镜子的锁");
Thread.sleep(1000);
synchronized (lipstick) { //一秒钟后想获得口红
System.out.println(this.girlName + "获得口红的锁");
}
}
}
}
}
//
灰姑凉获得口红的锁
白雪公主获得镜子的锁
(然后陷入僵持...)
如何解决这个问题呢,上面的情况是两人各握着两个锁,所以解决方案是,把另一个想要的锁放在外面
private void makeup() throws InterruptedException {
if (choice == 0) {
synchronized (lipstick) {//获得口红的锁
System.out.println(this.girlName + "获得口红的锁");
Thread.sleep(1000);
}
synchronized (mirrror) { //一秒钟后想获得镜子
System.out.println(this.girlName + "获得镜子的锁");
}
} else {
synchronized (mirrror) { //获得镜子的锁
System.out.println(this.girlName + "获得镜子的锁");
Thread.sleep(1000);
}
synchronized (lipstick) { //一秒钟后想获得口红
System.out.println(this.girlName + "获得口红的锁");
}
}
}
//
白雪公主获得镜子的锁
灰姑凉获得口红的锁
白雪公主获得口红的锁
灰姑凉获得镜子的锁
产生死锁的四个必要条件:
4.5 Lock锁
ReentrantLock可重入锁
Lock锁的书写格式:
class A{
private final ReentrantLock lock = new ReenTrantLock();
public void m(){
lock.lock();
try{
//保证线程安全的代码;
} finally {
lock.unlock();
//如果同步代码有异常,要将unlock()写入finally语句块
}
}
}
具体实现为:
import java.util.concurrent.locks.ReentrantLock;
//测试Lock锁
public class TestLock {
public static void main(String[] args) {
Lock testLock = new Lock();
new Thread(testLock).start();
new Thread(testLock).start();
new Thread(testLock).start();
}
}
class Lock implements Runnable {
int tickerNums = 10;
//定义Lock锁
private final ReentrantLock lock = new ReentrantLock();
@Override
public void run() {
while (true) {
//加锁
try {
lock.lock();
if (tickerNums <= 0) {
break;
}
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(tickerNums--);
} catch (Exception e) {
e.printStackTrace();
} finally {
//解锁
lock.unlock();
}
}
}
}
4.6 synchroized与lock对比
两种锁的对比:
五、线程通信问题
5.1 线程通信方法
典型的就是生产者和消费者问题
两者之间除了有需要锁的内容,还要互相依赖,相互传递消息,所以用之前的synchronized是不能实现的
java提供了2个方法用于解决线程之间的通信问题
那么如何解决线程之间的通信问题呢?
5.2 线程通信问题解决方式
解决方式1:管程法
package com.lxy.senior;
/**
* 测试:生产者消费者模型-->利用缓冲区解决:管程法
*/
public class TestPC {
public static void main(String[] args) {
SynContainer synContainer = new SynContainer();
new Producer(synContainer).start();
new Consumer(synContainer).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 Product(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 Product {
int id;//产品编号
public Product(int id) {
this.id = id;
}
}
//缓冲区
class SynContainer {
//需要一个容器大小
Product[] products = new Product[10];
//容器计数器
int count = 0;
//生产者放入产品
public synchronized void push(Product product) {
//如果容器满了,需要等待消费者消费
/*如果是if的话,假如消费者1消费了最后一个,这是index变成0此时释放锁被消费者2拿到而不是生产者拿到,
这时消费者的wait是在if里所以它就直接去消费index-1下标越界,如果是while就会再去判断一下index得值是不是变成0了*/
while (count == products.length) {
//通知消费者消费,等待生产
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//如果没有满,需要丢入产品
products[count] = product;
count++;
//通知消费者消费
this.notifyAll();
}
//消费者消费产品
public synchronized Product pop() {
//判断是否能消费
while (count <= 0) {
//等待生产者生产
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//如果可以消费
count--;
Product product = products[count];
//吃完了 通知生产者生产
this.notifyAll();
return product;
}
}
解决方式2:信号灯法
通过标志位标识,具体实现如下:
package demo;
public class TestPc2 {
public static void main(String[] args) {
TV tv = new TV();
new Actor(tv).start();
new Watcher(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("movies1 plays");
} else {
this.tv.play("movies2 plays");
}
}
}
}
//消费者-->观众
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 {
//演员表演的时候,观众等待 True
//观众观看的时候,演员等待 False
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;
}
}
六、线程高级主题
线程池
package com.lxy.senior;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
//测试线程池
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());
service.execute(new MyThread());
service.execute(new MyThread());
//关闭连接
service.shutdown();
}
}
class MyThread implements Runnable {
@Override
public void run() {
System.out.println(Thread.currentThread().getName());
}
}
内部类:
内部类就是在一个类的内部定义一个类,比如,A类中定义一个B类,那么B类相对于A类来说就成为内部类,而A类相对于B类来说就是外部类
成员内部类
静态内部类
局部内部类
匿名内部类
1、成员内部类:可以操作外部类的私有属性及方法
package demo;
public class Application {
public static void main(String[] args) {
Outer outer = new Outer();
//通过这个外部类来实例化年内部类
Outer.Inner inner = outer.new Inner();
inner.in();
inner.getID();
}
}
package demo;
public class Outer {
private int id = 10;
public void out(){
System.out.println("这是外部类的方法!");
}
public class Inner{
public void in(){
System.out.println("这是内部类的方法!");
}
//获得外部类的私有属性
public void getID(){
System.out.println(id);
}
}
}
//
这是内部类的方法!
10
2、静态内部类:static修饰,不能访问外部类私有属性
这里报错的原因是,static先加载,加载的时候id还没生成,所以访问不到
3、局部内部类:外部类的方法里定义的类
public class Outer{
public void method(){
//局部内部类Inner
class Inner{
public void in(){
}
}
}
}
4、匿名内部类:没有名字初始化类
public class Test{
public static void main(String[] args){
//没有名字初始化类,不用将实例保存在变量中
new Apple().eat();
UserService userservice = new UserService(){
@Override
public void hello(){}
};
}
}
class Apple{
public void eat(){
System.out.println("1");
}
}
interface UserService{
void hello();
}