文章目录
线程安全与锁的使用
当我们使用多个线程访问同一资源(可以是同一个变量、同一个文件、同一条记录等)的时候,若多个线程只有读操作,那么不会发生线程安全问题,但是如果多个线程中对资源有读和写的操作,就容易出现线程安全问题。
我们通过一个案例,演示线程的安全问题:
电影院要卖票,我们模拟电影院的卖票过程。假设要播放的电影是 “葫芦娃大战奥特曼”,本次电影的座位共100个
(本场电影只能卖100张票)。
我们来模拟电影院的售票窗口,实现多个窗口同时卖 “葫芦娃大战奥特曼”这场电影票(多个窗口一起卖这100张票)
同一个资源问题
1、局部变量不能共享
package com.atguigu.safe;
public class SaleTicketDemo1 {
public static void main(String[] args) {
Window w1 = new Window();
Window w2 = new Window();
Window w3 = new Window();
w1.start();
w2.start();
w3.start();
}
}
class Window extends Thread{
public void run(){
int total = 100;
while(total>0) {
System.out.println(getName() + "卖出一张票,剩余:" + --total);
}
}
}
结果:发现卖出300张票。
问题:局部变量是每次调用方法都是独立的,那么每个线程的run()的total是独立的,不是共享数据。
2、不同对象的实例变量不共享
package com.atguigu.safe;
public class SaleTicketDemo2 {
public static void main(String[] args) {
TicketSaleThread t1 = new TicketSaleThread();
TicketSaleThread t2 = new TicketSaleThread();
TicketSaleThread t3 = new TicketSaleThread();
t1.start();
t2.start();
t3.start();
}
}
class TicketSaleThread extends Thread{
private int total = 10;
public void run(){
while(total>0) {
System.out.println(getName() + "卖出一张票,剩余:" + --total);
}
}
}
结果:发现卖出300张票。
问题:不同的实例对象的实例变量是独立的。
3、静态变量是共享的
package com.atguigu.safe;
public class SaleTicketDemo3 {
public static void main(String[] args) {
TicketThread t1 = new TicketThread();
TicketThread t2 = new TicketThread();
TicketThread t3 = new TicketThread();
t1.start();
t2.start();
t3.start();
}
}
class TicketThread extends Thread{
private static int total = 10;
public void run(){
while(total>0) {
try {
Thread.sleep(10);//加入这个,使得问题暴露的更明显
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(getName() + "卖出一张票,剩余:" + --total);
}
}
}
结果:发现卖出近100张票。
问题(1):但是有重复票或负数票问题。
原因:线程安全问题
问题(2):如果要考虑有两场电影,各卖100张票等
原因:TicketThread类的静态变量,是所有TicketThread类的对象共享
等等如何解决呢?
尝试解决线程安全问题
要解决上述多线程并发访问一个资源的安全性问题:也就是解决重复票与不存在票问题,Java中提供了同步机制
(synchronized)来解决。
根据案例简述:
窗口1线程进入操作的时候,窗口2和窗口3线程只能在外等着,窗口1操作结束,窗口1和窗口2和窗口3才有机会进入代码去执行。也就是说在某个线程修改共享资源的时候,其他线程不能修改该资源,等待修改完毕同步之后,才能去抢夺CPU资源,完成对应的操作,保证了数据的同步性,解决了线程不安全的现象。
为了保证每个线程都能正常执行原子操作,Java引入了线程同步机制。注意:在任何时候,最多允许一个线程拥有同步锁,谁拿到锁就进入代码块,其他的线程只能在外等着(BLOCKED)。
同步方法:synchronized 关键字直接修饰方法,表示同一时刻只有一个线程能进入这个方法,其他线程在外面等着。
public synchronized void method(){
可能会产生线程安全问题的代码
}
同步代码块:synchronized 关键字可以用于某个区块前面,表示只对这个区块的资源实行互斥访问。
格式:
synchronized(同步锁){
需要同步操作的代码
}
锁对象选择
同步锁对象:
**- 锁对象可以是任意类型。
- 多个线程对象 要使用同一把锁。**
1、同步方法的锁对象问题
(1)静态方法:当前类的Class对象
(2)非静态方法:this
示例代码一:
public class SaleTicketSafeDemo1 {
public static void main(String[] args) {
// 2、创建资源对象
//注意这里只创建了一个对象 Ticket 所以是不用静态方法:当前类的Class对象而用非静态方法:this就可以了
Ticket ticket = new Ticket();
// 3、启动多个线程操作资源类的对象
//继承Thread类
//*使用匿名内部类对象来实现线程的创建和启动*
Thread t1 = new Thread("窗口一") {
public void run() {
while (true) {
try {
Thread.sleep(10);// 加入这个,使得问题暴露的更明显
ticket.sale();
} catch (Exception e) {
e.printStackTrace();
break;
}
}
}
};
Thread t2 = new Thread("窗口二") {
public void run() {
while (true) {
try {
Thread.sleep(10);// 加入这个,使得问题暴露的更明显
ticket.sale();
} catch (Exception e) {
e.printStackTrace();
break;
}
}
}
};
//实现Runnable接口
//*使用匿名内部类对象来实现线程的创建和启动*
Thread t3 = new Thread(new Runnable() {
public void run() {
while (true) {
try {
Thread.sleep(10);// 加入这个,使得问题暴露的更明显
ticket.sale();
} catch (Exception e) {
e.printStackTrace();
break;
}
}
}
}, "窗口三");
t1.start();
t2.start();
t3.start();
}
}
// 1、编写资源类
class Ticket {
private int total = 10;
//非静态方法隐含的锁对象就是this
//注意这里只创建了一个对象 Ticket 用非静态方法:this就可以了
public synchronized void sale() {
if (total > 0) {
System.out.println(Thread.currentThread().getName() + "卖出一张票,剩余:" + --total);
} else {
throw new RuntimeException(Thread.currentThread().getName() + "发现没有票了");
}
}
public int getTotal() {
return total;
}
}
示例代码二:
public class SaleTicketSafeDemo2 {
public static void main(String[] args) {
//注意这里只创建了一个对象 TicketRunnable所以是不用静态方法:当前类的Class对象而用非静态方法:this就可以了
TicketRunnable tr = new TicketRunnable();
Thread t1 = new Thread(tr,"窗口一");
Thread t2 = new Thread(tr,"窗口二");
Thread t3 = new Thread(tr,"窗口三");
t1.start();
t2.start();
t3.start();
}
}
class TicketRunnable implements Runnable {
private int ticket = 10;
@Override
public void run() {
while(ticket > 0){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
sellTicket();
}
}
//非静态方法隐含的锁对象就是this
//注意这里只创建了一个对象 TicketRunnable 用非静态方法:this就可以了
public synchronized void sellTicket() {
if (ticket > 0) {
System.out.println(Thread.currentThread().getName() + "正在卖:" + ticket--);
}
}
}
示例代码三:
public class SaleTicketSafeDemo3 {
public static void main(String[] args) {
//注意这里创建了三个对象 TicketThread 所以是用静态方法:当前类的Class对象 而用非静态方法this 不是唯一的对象标识
TicketThread t1 = new TicketThread();
TicketThread t2 = new TicketThread();
TicketThread t3 = new TicketThread();
t1.start();
t2.start();
t3.start();
}
}
class TicketThread extends Thread {
private static int ticket = 100;
@Override
public void run() {
while (ticket>0) {
try {
Thread.sleep(100);
} catch(InterruptedException e) {
e.printStackTrace();
}
sellTicket();
}
}
//这里必须是静态方法,因为如果是非静态方法,隐含的锁对象是this,那么多个线程就不是同一个锁对象了
//而静态方法隐含的锁对象是当前类的Class对象
public synchronized static void sellTicket(){
if(ticket>0){//有票可以卖
System.out.println(Thread.currentThread().getName() + "正在卖:" + ticket--);
}
}
}
2、同步代码块的锁对象
同步锁对象:
- 锁对象可以是任意类型。
- 多个线程对象 要使用同一把锁。
- 习惯上先考虑this,但是要注意是否同一个this
示例代码一:this对象
public class SaleTicketSafeDemo1 {
public static void main(String[] args) {
// 2、创建资源对象
Ticket ticket = new Ticket();
// 3、启动多个线程操作资源类的对象
Thread t1 = new Thread("窗口一") {
public void run() {
while (true) {
try {
Thread.sleep(10);// 加入这个,使得问题暴露的更明显
ticket.sale();
} catch (Exception e) {
e.printStackTrace();
break;
}
}
}
};
Thread t2 = new Thread("窗口二") {
public void run() {
while (true) {
try {
Thread.sleep(10);// 加入这个,使得问题暴露的更明显
ticket.sale();
} catch (Exception e) {
e.printStackTrace();
break;
}
}
}
};
Thread t3 = new Thread(new Runnable() {
public void run() {
while (true) {
try {
Thread.sleep(10);// 加入这个,使得问题暴露的更明显
ticket.sale();
} catch (Exception e) {
e.printStackTrace();
break;
}
}
}
}, "窗口三");
t1.start();
t2.start();
t3.start();
}
}
// 1、编写资源类
class Ticket {
private int total = 10;
public void sale() {
synchronized (this) {
if (total > 0) {
System.out.println(Thread.currentThread().getName() + "卖出一张票,剩余:" + --total);
} else {
throw new RuntimeException(Thread.currentThread().getName() + "发现没有票了");
}
}
}
public int getTotal() {
return total;
}
}
示例代码二:this对象
public class SaleTicketSafeDemo2 {
public static void main(String[] args) {
TicketRunnable tr = new TicketRunnable();
Thread t1 = new Thread(tr,"窗口一");
Thread t2 = new Thread(tr,"窗口二");
Thread t3 = new Thread(tr,"窗口三");
t1.start();
t2.start();
t3.start();
}
}
class TicketRunnable implements Runnable {
private int ticket = 10;
@Override
public void run() {
while(ticket > 0){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (this) {
if (ticket > 0) {
System.out.println(Thread.currentThread().getName() + "正在卖:" + ticket--);
}
}
}
}
}
示例代码三:其他对象
public class SaleTicketSafeDemo3 {
public static void main(String[] args) {
TicketThread t1 = new TicketThread();
TicketThread t2 = new TicketThread();
TicketThread t3 = new TicketThread();
t1.start();
t2.start();
t3.start();
}
}
class TicketThread extends Thread{
private static int total = 10;
private static final Object myLock = new Object();
public void run(){
while(total>0) {
try {
Thread.sleep(10);//加入这个,使得问题暴露的更明显
} catch (InterruptedException e) {
e.printStackTrace();
}
// synchronized (this) {//此处不能选this对象作为锁,因为this对于上面的三个线程来说是不同的
// synchronized (TicketThread.class) {//可以,因为在JVM中TicketThread类的Class对象只有一个
// synchronized ("") {//可以,因为在JVM中""字符串对象只有一个
synchronized (myLock) {//可以,因为在JVM中myLock对象只有一个
if(total>0){
System.out.println(getName() + "卖出一张票,剩余:" + --total);
}
}
}
}
}
锁的范围问题
锁的范围太小:不能解决安全问题
锁的范围太大:因为一旦某个线程抢到锁,其他线程就只能等待,所以范围太大,效率会降低,不能合理利用CPU资源。
如何编写多线程的程序呢?
-
原则:
- 线程操作资源类
- 高内聚低耦合
-
步骤:
- 编写资源类
- 考虑线程安全问题,在资源类中考虑使用同步代码块或同步方法
public class TestSynchronized {
public static void main(String[] args) {
// 2、创建资源对象
Ticket ticket = new Ticket();
// 3、启动多个线程操作资源类的对象
Thread t1 = new Thread("窗口一") {
public void run() {
while (true) {
try {
Thread.sleep(10);// 加入这个,使得问题暴露的更明显
ticket.sale();
} catch (Exception e) {
e.printStackTrace();
break;
}
}
}
};
Thread t2 = new Thread("窗口二") {
public void run() {
while (true) {
try {
Thread.sleep(10);// 加入这个,使得问题暴露的更明显
ticket.sale();
} catch (Exception e) {
e.printStackTrace();
break;
}
}
}
};
Thread t3 = new Thread(new Runnable() {
public void run() {
while (true) {
try {
Thread.sleep(10);// 加入这个,使得问题暴露的更明显
ticket.sale();
} catch (Exception e) {
e.printStackTrace();
break;
}
}
}
}, "窗口三");
t1.start();
t2.start();
t3.start();
}
}
// 1、编写资源类
class Ticket {
private int total = 10;
public synchronized void sale() {
if(total<=0){
throw new RuntimeException(Thread.currentThread().getName() + "发现没有票了");
}
System.out.println(Thread.currentThread().getName() + "卖出一张票,剩余:" + --total);
}
public int getTotal() {
return total;
}
}
单例设计模式的线程安全问题
1、饿汉式没有线程安全问题
public class OnlyOneDemo {
public static void main(String[] args) {
OnlyOne o1 = OnlyOne.INSTANCE;
OnlyOne o2 = OnlyOne.INSTANCE;
System.out.println(o1);
System.out.println(o2);
System.out.println(o1==o2);
}
}
class OnlyOne{
public static final OnlyOne INSTANCE = new OnlyOne();
private OnlyOne(){
}
}
2、懒汉式线程安全问题
延迟创建对象
```java
public class SingleTest {
@Test
public void test1() {
Single s1 = Single.getInstance();
Single s2 = Single.getInstance();
System.out.println(s1);
System.out.println(s2);
System.out.println(s1 == s2);
}
Single s1;
Single s2;
@Test
public void test2() throws InterruptedException {
new Thread(new Runnable() {
@Override
public void run() {
s1 = Single.getInstance();
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
s2 = Single.getInstance();
}
}).start();
Thread.sleep(1000);
System.out.println(s1 + " : " + s2);
System.out.println(s1 == s2);
}
}
```
等待唤醒机制
什么是等待唤醒机制
这是多个线程间的一种协作机制。谈到线程我们经常想到的是线程间的竞争(race),比如去争夺锁,但这并不是故事的全部,线程间也会有协作机制。
就是在一个线程满足某个条件时,就进入等待状态(wait()/wait(time)), 等待其他线程执行完他们的指定代码过后再将其唤醒(notify());或可以指定wait的时间,等时间到了自动唤醒;在有多个线程进行等待时,如果需要,可以使用 notifyAll()来唤醒所有的等待线程。wait/notify 就是线程间的一种协作机制。
- wait:线程不再活动,不再参与调度,进入 wait set 中,因此不会浪费 CPU 资源,也不会去竞争锁了,这时的线程状态即是 WAITING或TIMED_WAITING。它还要等着别的线程执行一个特别的动作,也即是“通知(notify)”或者等待时间到,在这个对象上等待的线程从wait set 中释放出来,重新进入到调度队列(ready queue)中
- notify:则选取所通知对象的 wait set 中的一个线程释放;
- notifyAll:则释放所通知对象的 wait set 上的全部线程。
注意:
被通知线程被唤醒后也不一定能立即恢复执行,因为它当初中断的地方是在同步块内,而此刻它已经不持有锁,所以她需要再次尝试去获取锁(很可能面临其它线程的竞争),成功后才能在当初调用 wait 方法之后的地方恢复执行。
总结如下:
- 如果能获取锁,线程就从 WAITING 状态变成 RUNNABLE(可运行) 状态;
- 否则,线程就从 WAITING 状态又变成 BLOCKED(等待锁) 状态
调用wait和notify方法需要注意的细节
- wait方法与notify方法必须要由同一个锁对象调用。因为:对应的锁对象可以通过notify唤醒使用同一个锁对象调用的wait方法后的线程。
- wait方法与notify方法是属于Object类的方法的。因为:锁对象可以是任意对象,而任意对象的所属类都是继承了Object类的。
- wait方法与notify方法必须要在同步代码块或者是同步函数中使用。因为:必须要通过锁对象调用这2个方法。
生产者与消费者问题
等待唤醒机制可以解决经典的“生产者与消费者”的问题。
生产者与消费者问题(英语:Producer-consumer problem),也称有限缓冲问题(英语:Bounded-buffer problem),是一个多线程同步问题的经典案例。该问题描述了两个(多个)共享固定大小缓冲区的线程——即所谓的“生产者”和“消费者”——在实际运行时会发生的问题。生产者的主要作用是生成一定量的数据放到缓冲区中,然后重复此过程。与此同时,消费者也在缓冲区消耗这些数据。该问题的关键就是要保证生产者不会在缓冲区满时加入数据,消费者也不会在缓冲区中空时消耗数据。
生产者与消费者问题中其实隐含了两个问题:
- 线程安全问题:因为生产者与消费者共享数据缓冲区,不过这个问题可以使用同步解决。
- 线程的协调工作问题:
- 要解决该问题,就必须让生产者线程在缓冲区满时等待(wait),暂停进入阻塞状态,等到下次消费者消耗了缓冲区中的数据的时候,通知(notify)正在等待的线程恢复到就绪状态,重新开始往缓冲区添加数据。同样,也可以让消费者线程在缓冲区空时进入等待(wait),暂停进入阻塞状态,等到生产者往缓冲区添加数据之后,再通知(notify)正在等待的线程恢复到就绪状态。通过这样的通信机制来解决此类问题。
一个厨师一个服务员问题
案例:有家餐馆的取餐口比较小,只能放10份快餐,厨师做完快餐放在取餐口的工作台上,服务员从这个工作台取出快餐给顾客。现在有1个厨师和1个服务员。
多个厨师多个服务员问题
案例:有家餐馆的取餐口比较小,只能放10份快餐,厨师做完快餐放在取餐口的工作台上,服务员从这个工作台取出快餐给顾客。现在有多个厨师和多个服务员。
练习
1、要求两个线程,同时打印字母,每个线程都能连续打印3个字母。两个线程交替打印,一个线程打印字母的小写形式,一个线程打印字母的大写形式,但是字母是连续的。当字母循环到z之后,回到a。
public class PrintLetterDemo {
public static void main(String[] args) {
// 2、创建资源对象
PrintLetter p = new PrintLetter();
// 3、创建两个线程打印
new Thread("小写字母") {
public void run() {
while (true) {
p.printLower();
try {
Thread.sleep(1000);// 控制节奏
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}.start();
new Thread("大写字母") {
public void run() {
while (true) {
p.printUpper();
try {
Thread.sleep(1000);// 控制节奏
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}.start();
}
}
// 1、定义资源类
class PrintLetter {
private char letter = 'a';
public synchronized void printLower() {
for (int i = 1; i <= 3; i++) {
System.out.println(Thread.currentThread().getName() + "->" + letter);
letter++;
if (letter > 'z') {
letter = 'a';
}
}
this.notify();
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public synchronized void printUpper() {
for (int i = 1; i <= 3; i++) {
System.out.println(Thread.currentThread().getName() + "->" + (char) (letter - 32));
letter++;
if (letter > 'z') {
letter = 'a';
}
}
this.notify();
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
线程生命周期
观点1:5种状态
简单来说,线程的生命周期有五种状态:新建(New)、就绪(Runnable)、运行(Running)、阻塞(Blocked)、死亡(Dead)。CPU需要在多条线程之间切换,于是线程状态会多次在运行、阻塞、就绪之间切换。
死锁
不同的线程分别锁住对方需要的同步监视器对象不释放,都在等待对方先放弃时就形成了线程的死锁。一旦出现死锁,整个程序既不会发生异常,也不会给出任何提示,只是所有线程处于阻塞状态,无法继续。
public class TestDeadLock {
public static void main(String[] args) {
Object g = new Object();
Object m = new Object();
Owner s = new Owner(g,m);
Customer c = new Customer(g,m);
new Thread(s).start();
new Thread(c).start();
}
}
class Owner implements Runnable{
private Object goods;
private Object money;
public Owner(Object goods, Object money) {
super();
this.goods = goods;
this.money = money;
}
@Override
public void run() {
synchronized (goods) {
System.out.println("先给钱");
synchronized (money) {
System.out.println("发货");
}
}
}
}
class Customer implements Runnable{
private Object goods;
private Object money;
public Customer(Object goods, Object money) {
super();
this.goods = goods;
this.money = money;
}
@Override
public void run() {
synchronized (money) {
System.out.println("先发货");
synchronized (goods) {
System.out.println("再给钱");
}
}
}
}
面试题:sleep()和wait()方法的区别
(1)sleep()不释放锁,wait()释放锁
(2)sleep()指定休眠的时间,wait()可以指定时间也可以无限等待直到notify或notifyAll
(3)sleep()在Thread类中声明的静态方法,wait方法在Object类中声明
因为我们调用wait()方法是由锁对象调用,而锁对象的类型是任意类型的对象。那么希望任意类型的对象都要有的方法,只能声明在Object类中。
java多线程run和start方法的区别
1 java中多线程有两个常见的方法start方法和run方法。正常来说run方法是多线程的线程体。
3 线程的使用。可以通过new Thread().start()方法来启动。
如:Thread1 thread1=new Thread1();
thread1.start();//这是创造新的线程
4 如果执行start方法,则会在主线程中重新创建一个新的线程,等得到cpu的时间段后则会执行所对应的run方法体的代码。
5 如果创建了线程对象后,执行run方法,则还是在主线程中执行,会和调用普通方法一样。按照顺序执行。
如:Thread1 thread1=new Thread1();
thread1.run();//这是普通方法,还是在主线程中
故:调用线程的start方法是创建了新的线程,在新的线程中执行。
调用线程的run方法是在主线程中执行该方法,和调用普通方法一样,