1. 多线程
1.1 概念
多线程就是指一个进程中同时有多个线程正在执行。
1.2 程序、进程、线程的区别
说起进程,就不得不说下程序。程序是指令和数据的有序集合,其本身没有任何运行的含义,是一个静态的概念。
而进程则是执行程序的一次执行过程,它是一个动态的概念。是系统资源分配的单位。
通常在一个进程中可以包含若干个线程,当然一个进程中至少有一个线程,不然没有存在的意义。线程是CPU调度和执行的的单位。
注意:很多多线程是模拟出来的,真正的多线程是指有多个cpu,即多核,如服务器。如果是模拟出来的多线程,即在一个cpu的情况下,在同一个时间点,cpu只能执行一个代码,因为切换的很快,所以就有同时执行的错局。
1.3 线程的创建方式
线程有三种创建方式
1.3.1 继承 Thread类
代码实现
// 继承Tread执行步骤:1.继承Tread 2.重写run方法 3. 创建线程对象,调用start方法执行线程
public class TreadTest extends Thread {
@Override
public void run() {
for (int i = 0; i < 2000; i++) {
System.out.println("多线程执行" + i);
}
}
public static void main(String[] args) {
// 创建线程对象
TreadTest treadTest = new TreadTest();
// 调用start方法开启线性
treadTest.start();
for (int i = 0; i < 2000; i++) {
System.out.println("主线程执行" + i);
}
}
}
总结:注意,线程开启不一定立即执行,由CPU调度执行。
当创建完对象后调用run方法,执行的结果是,先执行run方法,再执行主线程,原因是调用run方法相当于同一线程上调用普通的方法。
当创建完对象后调用start方法,执行的结果是,start方法和main方法相互执行,两条线程交替执行。
1.3.2 案例:下载图片
public class ThreadTest02 extends Thread {
private String url;
private String name;
public ThreadTest02(String url,String name) {
this.url = url;
this.name = name;
}
@Override
public void run() {
Webdownloader webdownloader = new Webdownloader();
webdownloader.downloader(this.name,this.url);
System.out.println("下载了文件名为:" + name );
}
public static void main(String[] args) {
ThreadTest02 t1 = new ThreadTest02("https://ss0.bdstatic.com/70cFvHSh_Q1YnxGkpoWK1HF6hhy/it/u=2653278343,3586655739&fm=26&gp=0.jpg","1.jpg");
ThreadTest02 t2 = new ThreadTest02("https://ss0.bdstatic.com/70cFvHSh_Q1YnxGkpoWK1HF6hhy/it/u=2653278343,3586655739&fm=26&gp=0.jpg","2.jpg");
ThreadTest02 t3 = new ThreadTest02("https://ss0.bdstatic.com/70cFvHSh_Q1YnxGkpoWK1HF6hhy/it/u=2653278343,3586655739&fm=26&gp=0.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("下载资源出错了");
}
}
}
1.3.3 实现Runnable接口
代码实现
// 继承Tread执行步骤:1.实现Runnable 2.重写run方法 3. 创建线程对象,调用start方法执行线程
public class TestTread03 implements Runnable {
@Override
public void run() {
for (int i = 0; i < 2000; i++) {
System.out.println("多线程执行" + i);
}
}
public static void main(String[] args) {
// 创建线程对象
TestTread03 t = new TestTread03();
new Thread(t).start();
for (int i = 0; i < 2000; i++) {
System.out.println("主线程执行" + i);
}
}
}
1.3.4 小结
1.3.5 实现callable接口
代码实现
// 继承Tread执行步骤:1.实现Callable 2.重写call方法, 3. 具有返回值,可以抛出异常
public class TestTread05 implements Callable<Boolean> {
private String url;
private String name;
public TestTread05(String url,String name) {
this.url = url;
this.name = name;
}
@Override
public Boolean call() {
Webdownloader2 webdownloader = new Webdownloader2();
webdownloader.downloader(name,url);
System.out.println("下载了文件名为:" + name );
return true;
}
public static void main(String[] args) throws ExecutionException, InterruptedException {
ThreadTest02 t1 = new ThreadTest02("https://ss0.bdstatic.com/70cFvHSh_Q1YnxGkpoWK1HF6hhy/it/u=2653278343,3586655739&fm=26&gp=0.jpg","1.jpg");
ThreadTest02 t2 = new ThreadTest02("https://ss0.bdstatic.com/70cFvHSh_Q1YnxGkpoWK1HF6hhy/it/u=2653278343,3586655739&fm=26&gp=0.jpg","2.jpg");
ThreadTest02 t3 = new ThreadTest02("https://ss0.bdstatic.com/70cFvHSh_Q1YnxGkpoWK1HF6hhy/it/u=2653278343,3586655739&fm=26&gp=0.jpg","3.jpg");
// 创建执行服务
ExecutorService ser = Executors.newFixedThreadPool(3);
// 提交执行
Future<Boolean> r1 = (Future<Boolean>) ser.submit(t1);
Future<Boolean> r2 = (Future<Boolean>) ser.submit(t2);
Future<Boolean> r3 = (Future<Boolean>) ser.submit(t3);
// 获取结果
Boolean rs1 = r1.get();
Boolean rs2 = r2.get();
Boolean rs3 = r3.get();
System.out.println(rs1);
System.out.println(rs2);
System.out.println(rs3);
// 关闭服务
ser.shutdown();
}
}
class Webdownloader2 {
public void downloader(String url,String name) {
try {
FileUtils.copyURLToFile(new URL(url),new File(name));
} catch (IOException e) {
e.printStackTrace();
System.out.println("下载资源出错了");
}
}
}
1.4 初始并发问题
多个线程同时操作同一个对象
买火车票的例子
public class TestTread04 implements Runnable {
private int ticketNum = 10;
@Override
public void run() {
while (true) {
if (ticketNum <= 0) {
break;
}
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"-->拿到了第" + ticketNum-- +"票");
}
}
public static void main(String[] args) {
TestTread04 t = new TestTread04();
new Thread(t,"小明").start();
new Thread(t,"老师").start();
new Thread(t,"黄牛党").start();
}
}
发现问题:多个线程操作同一个资源的情况下,线程不安全,数据紊乱。
总结:
每个线程在自己的工作内存交互,内存控制不当会造成数据不一致
1.5 案例:模拟龟兔赛跑-Race
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%10 ==0) {
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
// 判断比赛是否结束
boolean flag = gameOver(i);
if (flag) {
break;
}
System.out.println(Thread.currentThread().getName()+"跑了"+i+"步");
}
}
// 判断比赛是否结束
public boolean gameOver(int step) {
if (winner != null) {
return true;
}{
if (step >= 100) {
System.out.println("winner is" + Thread.currentThread().getName());
return true;
}
}
return false;
}
public static void main(String[] args) {
Race race = new Race();
new Thread(race,"兔子").start();
new Thread(race,"乌龟").start();
}
}
1.6 静态代理
Marry:做事情的接口
You:真实对象(目标对象)
MarryCompany:代理对象
传统的方法是自己去做这件事情,没有什么扩展性
new You().happyMarry();
利用代理对象帮你去做这件事,但目标对象还是你
new MarryCompany(new You()).happyMarry();
静态代理模式总结:
- 真实对象和代理对象都要实现同一个接口;
- 代理对象要代理真实角色
好处:
- 代理对象可以做很多真实对象做不了的事情
- 真实对象专注做自己的事情
回到本文话题,这个静态代理跟多线程有什么关系呢?
其实多线程调用的过程就是利用静态代理的模式进行执行的;
首先看多线程执行的代码;
new Thread(() -> System.out.println("我爱你")).start();
new Thread();其实是一个代理对象 ,查看源码会发现,Thread实现Runnable接口。
代码实现
public class StaticProxy {
public static void main(String[] args) {
new Thread(() -> System.out.println("我爱你")).start();
new MarryCompany(new You()).happyMarry();
}
}
interface Marry {
void happyMarry();
}
// 真实对象或者是目标对象
class You implements Marry {
@Override
public void happyMarry() {
System.out.println("我要结婚啦,真开心!!!");
}
}
class MarryCompany implements Marry {
You you;
public MarryCompany(You you) {
this.you = you;
}
@Override
public void happyMarry() {
before();
this.you.happyMarry();
after();
}
private void after() {
System.out.println("结婚后,收余款");
}
private void before() {
System.out.println("结婚前,布置场地");
}
}
1.7 Lamda表达
1.7.1 Lamda表达式的推导
函数式接口:只包含一个抽象方法的接口;
没有含参数
public class LamdaDemo {
// 3. 静态内部类
static class Like2 implements ILike {
@Override
public void lamda() {
System.out.println("lamda2");
}
}
public static void main(String[] args) {
ILike like = new Like();
like.lamda();
like = new Like2();
like.lamda();
// 4.局部内部类
class Like3 implements ILike {
@Override
public void lamda() {
System.out.println("lamda3");
}
}
like = new Like3();
like.lamda();
// 5.匿名内部类
like = new ILike() {
@Override
public void lamda() {
System.out.println("lamdb4");
}
};
like.lamda();
like =() -> { System.out.println("lamdb5");};
like.lamda();
};
// 6.lamda简化
}
// 1. 定义一个函数式接口
interface ILike {
void lamda();
}
// 2. 实现类
class Like implements ILike {
@Override
public void lamda() {
System.out.println("lamda1");
}
}
只有一个参数的时候
总结:
- 参数的数据类型和括号都可以省略;
- 方法体可以省略,即{ }
public class LamdaDemo02 {
public static void main(String[] args) {
Ilike like = a -> {
System.out.println("I love you "+a);
};
like.lamda(520);
}
}
interface Ilike {
void lamda(int a);
}
多个参数的时候
总结:
1.方法参数数据类型可以省略,但括号不可省略;(要么只省略数据类型;要么省略花括号和数据类型)
2.当方法体中只有一条语句时,花括号可以省略,有2条语句则花括号不能省略;
public class LamdaDemo03 {
public static void main(String[] args) {
ILike2 like =(a, b)-> {
System.out.println("I love you "+a);
System.out.println("I love you "+b);
};
like.lamda(520,502);
}
}
interface ILike2 {
void lamda(int a, int b);
}
总结:
- lambda表达式只能有一行代码的情况下才能简化成为一行,如果有多行,那么就用代码块包裹
- 前提是接口为函数式接口
- 多个参数也可以去掉参数类型,要去掉就都去掉,必须加上括号,
1.8 线程状态
1.8.1 方法说明
方法 | 说明 |
---|---|
setPriority(int newPriority) | 更改线程的优先级 |
static void sleep(long millis) | 在指定的毫秒数内让当前正在执行的线程休眠 |
void join() | 等待该线程终止 |
static void yield() | 暂停当前正在执行的线程对象,并执行其他线程 |
void interrupt() | 中断线程,别用这个方式 |
boolean isAlive() | 测试线程是否处于活动状态 |
1.8.2 线程停止
- 不推荐使用JDK提供的stop().destroy()方法。【已废弃】推荐线程自己停止下来
- 建议使用一个标志位进行终止变量当flag=false,则终止线程运行。
1.8.3 线程休眠
- sleep(时间)指定当前线程阻塞的毫秒数;
- sleep存在异常InterruptedException;
- sleep时间达到后线程进入就绪状态;
- sleep可以模拟网络延时,倒计时等。
- 每一个对象都有一个锁,sleep不会释放锁;
模拟倒计时
public class SleepDemo {
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;
}
}
}
}
1.8.4 线程礼让
- 礼让线程,让当前正在执行的线程暂停,但不阻塞
- 将线程从运行状态转为就绪状态
- 让cpu重新调度,礼让不一定成功!看CPU心情
public class YieldDemo {
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()+"线程停止");
}
}
1.8.5 线程强制执行
- Join合并线程,待此线程执行完成后,再执行其他线程, 其他线程阻塞
- 可以想象成插队
public class JoinDemo implements Runnable {
@Override
public void run() {
for (int j = 0; j < 500; j++) {
System.out.println("线程VIP执行"+j);
}
}
public static void main(String[] args) throws InterruptedException {
JoinDemo joinDemo = new JoinDemo();
Thread thread = new Thread(joinDemo);
thread.start();
for (int i = 0; i < 1000; i++) {
if (i == 200) {
thread.join();//线程插队
}
System.out.println("主线程执行"+i);
}
}
}
1.8.6 线程观测状态
Thread.State
线程状态。线程可以处于以下状态之一:
- NEW
尚未启动的线程处于此状态。 - RUNNABLE
在Java虚拟机中执行的线程处于此状态。 - 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);
// 启动
thread.start();
state = thread.getState();
System.out.println(state);
while (state != Thread.State.TERMINATED) {
Thread.sleep(100);
System.out.println(state);
state = thread.getState();
}
System.out.println(state);
}
}
1.9 线程优先级
Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程,线程调度器按照优先级决定应该调度哪个线程来执行。
-
线程的优先级用数字表示,范围从1~10.
Thread.MIN_PRIORITY = 1;
Thread.MAX_PRIORITY = 10;Thread.NORM_PRIORITY = 5; -
使用以下方式改变或获取优先级
getPriority()
setPriority(int xxx)
注意:优先级高的不一定先执行,得看CPU调度;但大多数情况下,优先级高优先执行。
public class ProrityTest implements Runnable {
public static void main(String[] args) {
System.out.println(Thread.currentThread().getName()+"--->"+Thread.currentThread().getPriority());
ProrityTest prorityTest = new ProrityTest();
Thread t1 = new Thread(prorityTest,"t1");
Thread t2 = new Thread(prorityTest,"t2");
Thread t3 = new Thread(prorityTest,"t3");
Thread t4 = new Thread(prorityTest,"t4");
Thread t5 = new Thread(prorityTest,"t5");
Thread t6= new Thread(prorityTest,"t6");
t1.start();
t2.setPriority(Thread.MIN_PRIORITY);
t2.start();
t3.setPriority(4);
t3.start();
t4.setPriority(Thread.NORM_PRIORITY);
t4.start();
t5.setPriority(6);
t5.start();
t6.setPriority(Thread.MAX_PRIORITY);
t6.start();
}
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"--->"+Thread.currentThread().getPriority());
}
}
1.10 守护线程
- 线程分为用户线程和守护线程
- 虚拟机必须确保用户线程执行完毕
- 虚拟机不用等待守护线程执行完毕
- 如,后台记录操作日志监控内存,垃圾回收等待…
public class DaemoTest {
public static void main(String[] args) {
God god = new God();
You you = new You();
Thread thread = new Thread(god);
thread.setDaemon(true);
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("==============Good Bye world===========");
}
}
2. 线程同步
多个线程操作同一个对象
处理多线程问题时,多个线程访问同一个对象,并且某些线程还想修改这个对象.这时候我们就需要线程同步.线程同步其实就是一种等待机制 ,多个需要同时访问此对象的线程进入这个对象的等待池形成队列,等待前面线程使用完毕,下一个线程再使用。
形成的条件:队列+锁(为了解决线程不安全的问题)
- 由于同一进程的多个线程共享同-块存储空间,在带来方便的同时,也带来了访问冲突问题,为了保证数据在方法中被访问时的正确性,在访问时加入锁机制synchronized ,当-一个线程获得对象的排它锁,独占资源,其他线程必须等待,使用后释放锁即可. 存在以下问题:
- 一个线程持有锁会导致其他所有需要此锁的线程挂起;(导致效率降低)
- 在多线程竞争下,加锁,释放锁会导致比较多的上下文切换和调度延时,引起性能问题;(导致性能降低)
- 如果一个优先级高的线程等待一个优先级低的线程释放锁 会导致优先级倒置,引起性能问题.(导致优先级导致)
2.1 三大线程不安全案例
2.1.1 不安全买票问题
public class UnSafeBuyTicket implements Runnable {
private int ticketNums = 10;
boolean flag = true;
public static void main(String[] args) {
UnSafeBuyTicket t1 = new UnSafeBuyTicket();
new Thread(t1,"学生").start();
new Thread(t1,"老师").start();
new Thread(t1,"黄牛党").start();
}
@Override
public void run() {
while (flag) {
try {
buy();
} catch (Exception e) {
e.printStackTrace();
}
}
}
public void buy() throws InterruptedException {
if (ticketNums <=0) {
flag = false;
return;
}
// 模拟延迟
Thread.sleep(1000);
System.out.println(Thread.currentThread().getName()+"买了票"+ticketNums--);
}
}
2.1.2 不安全银行取款问题
public class UnSafeBank {
public static void main(String[] args) {
Acount acount = new Acount(100,"小金库");
Drawing you = new Drawing(acount,50,"你");
Drawing girlFriend = new Drawing(acount,100,"女朋友");
you.start();
girlFriend.start();
}
}
// 账户
class Acount {
int money;
String name;
public Acount(int money, String name) {
this.money = money;
this.name = name;
}
}
// 模拟取钱
class Drawing extends Thread {
Acount acount;// 账户
int drawingMoney;// 取出的钱
int nowMoney;// 手里的钱
public Drawing(Acount acount, int drawingMoney, String name) {
super(name);
this.acount = acount;
this.drawingMoney = drawingMoney;
}
@Override
public void run() {
// 判断卡里的钱够不够
if (acount.money - drawingMoney < 0) {
System.out.println(Thread.currentThread().getName()+"钱不够了");
return;
}
// sleep可以放大问题的发生性
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//卡里的余额 = 卡里的钱 - 取出的钱
acount.money = acount.money - drawingMoney;
//手里的钱 = 手里的钱 + 取出的钱
nowMoney = nowMoney + drawingMoney;
System.out.println(acount.name+"余额为"+acount.money);
System.out.println(this.getName()+"手里的钱"+nowMoney);
}
}
2.1.3 不安全添加元素问题
public class UnSafeList {
public static void main(String[] args) {
List list = new ArrayList();
for (int i = 0; i < 10000; i++) {
new Thread(()->{
list.add(Thread.currentThread().getName());
}).start();
}
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(list.size());
}
}
2.2 同步方法
2.2.1 同步方法
◆由于我们可以通过private关键字来保证数据对象只能被方法访问,所以我们只需要针对方法提出一套机制,这套机制就是synchronized
关键字,它包括两种用法:synchronized方法和synchronized块.
同步方法: public synchronized void method(int args) {}
◆synchronized方法控制对“对象”的访问,每个对象对应一把锁,每个synchronized方法都必须获得调用该方法的对象的锁才能执行,否则线程会阻塞,方法一旦执行,就独占该锁,直到该方法返回才释放锁,后面被阻塞的线程才能获得这个锁,继续执行
缺陷:若将一个大的方法申明为synchronized将会影响效率
2.2.2 同步块
- 同步块:
synchronized (Obj ){ }
- Obj称之为同步监视器
- Obj可以是任何对象,但是推荐使用共享资源作为同步监视器
- 同步方法中无需指定同步监视器,因为同步方法的同步监视器就是this ,就是这个对象本身,或者是class [反射中讲解]
- 同步监视器的执行过程
- 第一个线程访问,锁定同步监视器,执行其中代码.
- 第二个线程访问 ,发现同步监视器被锁定,无法访问.
- 第一个线程访问完毕,解锁同步监视器.
- 第二个线程访问,发现同步监视器没有锁,然后锁定并访问
2.2.3 解决不安全买票问题
synchronized 是同步方法,锁的是this即UnSafeBuyTicket对象
public synchronized void buy() throws InterruptedException {
if (ticketNums <=0) {
flag = false;
return;
}
// 模拟延迟
Thread.sleep(1000);
System.out.println(Thread.currentThread().getName()+"买了票"+ticketNums--);
}
2.2.4 解决不安全银行取钱问题
当我们在取钱的函数上加上synchronized发现依然会出现线程不安全的问题,原因是synchronized锁的对象是Drawing(银行),而我们主要操作的对象是Account(银行卡),所以锁错对象了。
@Override
public synchronized void run() {
// 判断卡里的钱够不够
if (acount.money - drawingMoney < 0) {
System.out.println(Thread.currentThread().getName()+"钱不够了");
return;
}
// sleep可以放大问题的发生性
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//卡里的余额 = 卡里的钱 - 取出的钱
acount.money = acount.money - drawingMoney;
//手里的钱 = 手里的钱 + 取出的钱
nowMoney = nowMoney + drawingMoney;
System.out.println(acount.name+"余额为"+acount.money);
System.out.println(this.getName()+"手里的钱"+nowMoney);
}
解决方法:synchronized同步块
锁的对象就是变化的量,需要增删改的对象
@Override
public synchronized void run() {
//锁的对象就是变化的量,需要增删改的对象
synchronized(acount) {
// 判断卡里的钱够不够
if (acount.money - drawingMoney < 0) {
System.out.println(Thread.currentThread().getName()+"钱不够了");
return;
}
// sleep可以放大问题的发生性
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//卡里的余额 = 卡里的钱 - 取出的钱
acount.money = acount.money - drawingMoney;
//手里的钱 = 手里的钱 + 取出的钱
nowMoney = nowMoney + drawingMoney;
System.out.println(acount.name+"余额为"+acount.money);
System.out.println(this.getName()+"手里的钱"+nowMoney);
}
}
2.2.5 解决不安全添加元素问题
public class UnSafeList {
public static void main(String[] args) {
List list = new ArrayList();
for (int i = 0; i < 10000; i++) {
new Thread(()->{
synchronized (list) {
list.add(Thread.currentThread().getName());
}
}).start();
}
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(list.size());
}
}
2.3 扩充: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(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(list.size());
}
}
为什么 CopyOnWriteArrayList添加的元素是线程安全的呢?
我们查看源码
首先点击CopyOnWriteArrayList
/**
* Creates an empty list.
*/
public CopyOnWriteArrayList() {
setArray(new Object[0]);
}
再点击setArray方法
/**
* Sets the array.
*/
final void setArray(Object[] a) {
array = a;
}
点击array
/** The array, accessed only via getArray/setArray. */
private transient volatile Object[] array;
最终发现array是用volatitle修饰线程安全的。
2.4 死锁
多个线程各自占有一些共享资源,并且互相等待其他线程占有的资源才能运行,而导致两个或者多个线程都在等待对方释放资源,都停止执行的情形。(死锁:多个线程互相抱着对方需要的资源,然后形成僵持)
某一个同步块同时拥有“两个以上对象的锁”时,就可能会发生“死锁”的问题。(解决方法:将包含的其中一个对象锁提取到外面)
女生化妆案例
造成死锁
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;// 人-选择
public Makeup(int choice, String girlName) {
this.choice = choice;
this.girlName = girlName;
}
String 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+"获得镜子的锁");
}
}
} else {
synchronized (mirror) {
System.out.println(this.girlName+"获得镜子的锁");
Thread.sleep(3000);
synchronized (lipstick) {
System.out.println(this.girlName+"获得口红的锁");
}
}
}
}
}
解决方法:将包含的其中一个对象锁提取到外面
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;// 人-选择
public Makeup(int choice, String girlName) {
this.choice = choice;
this.girlName = girlName;
}
String 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+"获得镜子的锁");
}
} else {
synchronized (mirror) {
System.out.println(this.girlName+"获得镜子的锁");
Thread.sleep(3000);
}
synchronized (lipstick) {
System.out.println(this.girlName+"获得口红的锁");
}
}
}
}
死锁避免方法
产生死锁的四个必要条件:
- 互斥条件: 一个资源每次只能被一个进程使用。
- 请求与保持条件: 一个进程因请求资源而阻塞时,对已获得的资源保持不放。
- 不剥夺条件:进程已获得的资源,在末使用完之前,不能强行剥夺。
- 循环等待条件:若干进程之间形成-种头尾相接的循环等待资源关系。
总结:
上面列出了死锁的四个必要条件,我们只要想办法破其中的任意一个或多个条件就可以避免死锁发生
2.5 Lock(锁)
隐式锁:synchronized(即锁的不知道是哪个对象)
显式锁:Lock
◆java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。
锁提供了对共享资源的独占访问,每次只能有一个线程对L ock对象加锁,线程开始访问共享资源之前应先获得Lock对象。
◆ReentrantLock (可重入锁)类实现了Lock,它拥有与synchronized相同的并发性和内存语义,在实现线程安全的控制中,比较常用的是ReentrantLock, 可以显式加锁、释放锁。
2.5.1 语法:
class A{
private final ReentrantLock lock = new ReenTrantLock();
public void m(){
lock.lock();
try{
//保证线程安全的代码;
}
finally{
lock.unlock);//如果同步代码有异常,要将unlock()写入finally语句块
}
}
}
}
2.5.2 案例:使用ReentrantLock解决不安全买票问题
public class ReentrantLockDemo {
public static void main(String[] args) {
BuyTicket b1 = new BuyTicket();
new Thread(b1).start();
new Thread(b1).start();
new Thread(b1).start();
}
}
class BuyTicket implements Runnable{
int ticketNum = 10;
private final ReentrantLock lock = new ReentrantLock();
@Override
public void run() {
while (true) {
lock.lock();//加锁
try {
if (ticketNum > 0) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(ticketNum--);
} else {
break;
}
} finally {
lock.unlock();//释放锁
}
}
}
}
2.5.3synchronized与Lock的对比
- Lock是显式锁(手动开启和关闭锁,别忘记关闭锁) synchronized是隐式锁, 出了作用域自动释放
- Lock只有代码块锁,synchronized有代码块锁和方法锁
- 使用Lock锁,JVM将花费较少的时间来调度线程,性能更好。并且具有更好的扩展
性(提供更多的子类) - 优先使用顺序:
Lock >同步代码块(已经进入了方法体,分配了相应资源) >同步方法(在方法体之外)
3. 线程协作(生产者消费者模式)
3.1 线程通信
应用场景:生产者和消费者问题
- 假设仓库中只能存放一件产品,生产者将生产出来的产品放入仓库,消费者将仓库中产品取走消费。
- 如果仓库中没有产品,则生产者将产品放入仓库,否则停止生产并等待,直到仓库中的产品被消费者取走为止。
- 如果仓库中放有产品,则消费者可以将产品取走消费,否则停止消费并等待,直到仓库中再次放入产品为止。
3.2 线程通信-分析
这是一个线程同步问题,生产者和消费者共享同一个资源,并且生产者和消费者之间相互依赖,互为条件。
- 对于生产者,没有生产产品之前,要通知消费者等待.而生产了产品之后,又要马上通知消费者消费。
- 对于消费者, 在消费之后,要通知生产者已经结束消费,需要生产新的产品以供消费。
- 在生产者消费者问题中,仅有synchronized是不够的
◆synchronized可阻止并发更新同一个共享资源,实现了同步
◆synchronized 不能用来实现不同线程之间的消息传递(通信)
3.3 线程通信
Java提供了几个方法解决线程之间的通信问题
方法名 | 作用 |
---|---|
wait() | 表示线程一直等待 ,直到其他线程通知,与sleep不同,会释放锁 |
wait(long timeout) | 指定等待的毫秒数 |
notify() | 唤醒一个处于等待状态的线程 |
notifyAll() | 唤醒同一个对象上所有调用wait()方法的线程,优先级别高的线程优先调度 |
注意:均是Object类的方法,都只能在同步方法或者同步代码块中使用,否则会抛出异常llegalMonitorStateException
3.4 解决通信的方法
3.4.1 管道法
并发协作模型“生产者/消费者模式”–>管程法
- 生产者:负责生产数据的模块(可能是方法,对象,线程,进程);
- 消费者:负责处理数据的模块(可能是方法,对象,线程,进程);
- 缓冲区:消费者不能直接使用生产者的数据,他们之间有个“缓冲区
生产者将生产好的数据放入缓冲区,消费者从缓冲区拿出数据
生产者只顾生产,生产完了就等待消费者消费;
消费者只顾消费,消费完了就等待生产者生产;
public class TestPC {
public static void main(String[] args) {
SynContainer synContainer = new SynContainer();
new Producter(synContainer).start();
new Customer(synContainer).start();
}
}
//生产者
class Producter extends Thread {
SynContainer synContainer;
public Producter(SynContainer synContainer) {
this.synContainer = synContainer;
}
@Override
public void run() {
for (int i = 0; i < 100; i++) {
synContainer.push(new Chicken(i));
System.out.println("生产了"+i+"只鸡");
}
}
}
//消费者
class Customer extends Thread {
SynContainer synContainer;
public Customer(SynContainer synContainer) {
this.synContainer = synContainer;
}
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println("消费了"+synContainer.pop().id+"只鸡");
}
}
}
//产品
class Chicken {
// 产品编号
int id;
public Chicken(int id) {
this.id = id;
}
}
//缓冲区
class SynContainer {
//定义的容器
Chicken[] chickens = new Chicken[10];
//生产产品计数
int count;
// 生产者生产产品
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;
}
}
3.4.2 信号法
并发协作模型"生产者1消费者模式”–>信号灯法(判断一个标志位)
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 < 100; 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 < 100; i++) {
this.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.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;
}
}
4. 线程池
-
背景:经常创建和销毁、使用量特别大的资源,比如并发情况下的线程,对性能影响很大。
-
思路:提前创建好多个线程,放入线程池中,使用时直接获取,使用完放回池中。
可以避免频繁创建销毁、实现重复利用。类似生活中的公共交通工具。
-好处:- 提高响应速度(减少了创建新线程的时间)
- 降低资源消耗(重复利用线程池中线程,不需要每次都创建)
- 便于线程管理(…)
corePoolSize
: 核心池的大小maximumPoolSize
: 最大线程数keepAliveTime
: 线程没有任务时最多保持多长时间后会终止
-
JDK 5.0起提供了线程池相关API: ExecutorService 和Executors
-
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(10);
//2.执行
service.submit(new MyTest());
service.submit(new MyTest());
service.submit(new MyTest());
service.submit(new MyTest());
service.submit(new MyTest());
//3.关闭链接
service.shutdown();
}
}
class MyTest implements Runnable {
@Override
public void run() {
System.out.println(Thread.currentThread().getName());
}
}
5. 总结
5.1 线程创建
1.继承Thread
2.实现Runnable
3.实现Callable
4.线程池创建
5.2 线程的静态代理
5.3 Lamda表达式
5.4 线程状态
5.5 线程优先级
5.6 线程同步
5.7 Lock锁
5.8 线程通信
内容参考:https://www.bilibili.com/video/BV1V4411p7EF?p=1