JavaSE|线程安全
案例与线程安全
两种方式实现模拟电影院售票
需求:某电影院目前正在上映贺岁大片,共有100张票,而它有3个售票窗口售票,请设计一个程序模拟该电影院售票。
两种方式实现:
- 继承Thread类
- 实现Runnable接口
// 继承Thread类的方式
public class SellTicketDemo {
/**
* @param args
*/
public static void main(String[] args) {
SellTicket st1 = new SellTicket();
SellTicket st2 = new SellTicket();
SellTicket st3 = new SellTicket();
st1.setName("窗口1");
st2.setName("窗口2");
st3.setName("窗口3");
st1.start();
st2.start();
st3.start();
}
}
public class SellTicket extends Thread {
// 此处一定要用static,共享数据
private static int ticket = 100;
@Override
public void run() {
while(true){
if(ticket > 0){
System.out.println(getName() + "正在售卖第" + (ticket--) + "张票");
}
}
}
}
// 实现Runnable接口方式
public class SellTicketDemo {
/**
* @param args
*/
public static void main(String[] args) {
SellTicket st = new SellTicket();
Thread t1 = new Thread(st, "窗口1");
Thread t2 = new Thread(st, "窗口2");
Thread t3 = new Thread(st, "窗口3");
t1.start();
t2.start();
t3.start();
}
}
public class SellTicket implements Runnable{
private int ticket = 100;
@Override
public void run() {
while(true){
if(ticket > 0){
System.out.println(Thread.currentThread().getName() + "正在售卖第" + (ticket--) + "张票");
}
}
}
}
实现Runnable接口的方式比继承Thread类的方式更适合这个案例。三个售票窗口共享同一个剩余票数,使用Thread类时,由于需要创建三个Thread实例,所以必须将剩余票数设置为static的成员变量。而实现Runnable接口的方式中只有一个实现Runnable接口的实例,即共享的数据本来就只有一份,将数据有效分离,代码更优雅。
增加售票延迟
电影院售票程序,从表面上看不出什么问题,但是在真实生活中,售票时网络是不能实时传输的,总是存在延迟的情况,所以,在出售一张票以后,需要一点时间的延迟。
需求:改实现接口方式的卖票程序,每次卖票延迟100毫秒。
public class SellTicketDemo {
/**
* @param args
*/
public static void main(String[] args) {
SellTicket st = new SellTicket();
Thread t1 = new Thread(st, "窗口1");
Thread t2 = new Thread(st, "窗口2");
Thread t3 = new Thread(st, "窗口3");
t1.start();
t2.start();
t3.start();
}
}
public class SellTicket implements Runnable{
private int ticket = 100;
@Override
public void run() {
while(true){
if(ticket > 0){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "正在售卖第" + (ticket--) + "张票");
}
}
}
}
相同的票出现多次:
出现负数结果:
加入延迟后,我们发现出现了两个问题:
- 相同的票出现多次
CPU的一次操作必须是原子性的 - 还出现了负数的票
随机性和延迟导致的
注意:
线程安全问题在理想状态下,不容易出现,但一旦出现对软件的影响是非常大的。
解决线程安全问题的基本思想
首先想为什么出现问题?(也是我们判断是否有问题的标准)
- 是否是多线程环境
- 是否有共享数据
- 是否有多条语句操作共享数据
如何解决多线程安全问题呢?
基本思想:让程序没有安全问题的环境。
怎么实现呢?
把多个语句操作共享数据的代码给锁起来,让任意时刻只能有一个线程执行即可。
同步:解决线程安全问题
解决线程安全问题实现1
即同步代码块。
格式:synchronized(对象){需要同步的代码;}
同步可以解决安全问题的根本原因就在那个对象上。该对象如同锁的功能。
同步代码块的对象可以是哪些呢?
下面代码使用的Object,其实可以是任意对象,例如自定义的类等。
同步代码块用obj做锁:
public class SellTicketDemo {
/**
* @param args
*/
public static void main(String[] args) {
SellTicket st = new SellTicket();
Thread t1 = new Thread(st, "窗口1");
Thread t2 = new Thread(st, "窗口2");
Thread t3 = new Thread(st, "窗口3");
t1.start();
t2.start();
t3.start();
}
}
public class SellTicket implements Runnable{
// 定义100张票
private int ticket = 100;
// 定义同一把锁
private Object obj = new Object();
@Override
public void run() {
while(true){
synchronized(obj){
if(ticket > 0){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "正在售卖第" + (ticket--) + "张票");
}
}
}
}
}
同步代码块用任意对象做锁:
public class SellTicket implements Runnable {
// 定义100张票
private static int tickets = 100;
// 定义同一把锁
private Demo d = new Demo();
//同步代码块用任意对象做锁
@Override
public void run() {
while (true) {
synchronized (d) {
if (tickets > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()
+ "正在出售第" + (tickets--) + "张票 ");
}
}
}
}
class Demo {
}
同步的特点
同步的前提:
- 多个线程
- 多个线程使用的是同一个锁对象
同步的好处:同步的出现解决了多线程的安全问题。
同步的弊端:当线程相当多时,因为每个线程都会去判断同步上的锁,这是很耗费资源的,无形中会降低程序的运行效率。
解决线程安全问题实现2
即同步方法。
格式:把同步关键字加到方法上。
问题:
-
同步方法的锁对象是什么呢?
this -
如果是静态方法,同步方法的锁对象又是什么呢?
类的字节码文件。 -
那么,我们到底使用谁?
如果锁对象是this,就可以考虑使用同步方法。
否则能使用同步代码块的尽量使用同步代码块。
同步非静态方法,用this作锁:
public class SellTicket implements Runnable {
// 定义100张票
private static int tickets = 100;
// 定义同一把锁
private Object obj = new Object();
private int x = 0;
@Override
public void run() {
while (true) {
if(x%2==0){
synchronized (this) {
if (tickets > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()
+ "正在出售第" + (tickets--) + "张票 ");
}
}
}else {
sellTicket();
}
x++;
}
}
private synchronized void sellTicket() {
if (tickets > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()
+ "正在出售第" + (tickets--) + "张票 ");
}
}
}
同步静态方法,用该类的字节码文件作锁:
public class SellTicket implements Runnable {
// 定义100张票
private static int tickets = 100;
// 定义同一把锁
private Object obj = new Object();
private int x = 0;
@Override
public void run() {
while (true) {
if(x%2==0){
synchronized (SellTicket.class) {
if (tickets > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()
+ "正在出售第" + (tickets--) + "张票 ");
}
}
}else {
sellTicket();
}
x++;
}
}
private static synchronized void sellTicket() {
if (tickets > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()
+ "正在出售第" + (tickets--) + "张票 ");
}
}
}
线程安全的类
StringBuffer、Vector、Hashtable都是线程安全的类,通过查看源码我们看到,类中几乎每一个方法都加了synchronized关键字。
Vector是线程安全的时候才去考虑使用的,但是即使要安全,也不用Vector,可以通过Collections集合的静态方法,得到线程安全的集合。例如:
public static List synchronizedList(List list)
public class ThreadDemo {
public static void main(String[] args) {
// 线程安全的类
StringBuffer sb = new StringBuffer();
Vector<String> v = new Vector<String>();
Hashtable<String, String> h = new Hashtable<String, String>();
// Vector是线程安全的时候才去考虑使用的,但是我还说过即使要安全,我也不用你
// 那么到底用谁呢?
// public static <T> List<T> synchronizedList(List<T> list)
List<String> list1 = new ArrayList<String>();// 线程不安全
List<String> list2 = Collections
.synchronizedList(new ArrayList<String>()); // 线程安全
}
}
JDK5中Lock锁的使用
虽然我们可以理解同步代码块和同步方法的锁对象问题,但是我们并没有直接看到在哪里加上了锁,在哪里释放了锁,为了更清晰的表达如何加锁和释放锁,JDK5以后提供了一个新的锁对象Lock。
Lock是一个接口,使用的时候需要实例化为其子类对象。(如ReentrantLock是Lock的实现类)
Lock使用的一般格式:
Lock l = ...;
l.lock();
try {
// access the resource protected by this lock
} finally {
l.unlock();
}
void lock():获取锁。
void unlock():释放锁。
将Lock应用在电影院售票程序中如下:
public class SellTicketDemo {
public static void main(String[] args) {
// 创建资源对象
SellTicket st = new SellTicket();
// 创建三个窗口
Thread t1 = new Thread(st, "窗口1");
Thread t2 = new Thread(st, "窗口2");
Thread t3 = new Thread(st, "窗口3");
// 启动线程
t1.start();
t2.start();
t3.start();
}
}
public class SellTicket implements Runnable {
// 定义票
private int tickets = 100;
// 定义锁对象
private Lock lock = new ReentrantLock();
@Override
public void run() {
while (true) {
try {
// 加锁
lock.lock();
if (tickets > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()
+ "正在出售第" + (tickets--) + "张票");
}
} finally {
// 释放锁
lock.unlock();
}
}
}
}
死锁
同步弊端:1)效率低;2)如果出现了同步嵌套,就容易产生死锁问题
死锁就是指两个或者两个以上的线程在执行的过程中,因争夺资源产生的一种互相等待现象。
同步代码块的嵌套案例如下:
public class DieLockDemo {
public static void main(String[] args) {
DieLock dl1 = new DieLock(true);
DieLock dl2 = new DieLock(false);
dl1.start();
dl2.start();
}
}
public class MyLock {
// 创建两把锁对象
public static final Object objA = new Object();
public static final Object objB = new Object();
}
public class DieLock extends Thread {
private boolean flag;
public DieLock(boolean flag) {
this.flag = flag;
}
@Override
public void run() {
if (flag) {
synchronized (MyLock.objA) {
System.out.println("if objA");
synchronized (MyLock.objB) {
System.out.println("if objB");
}
}
} else {
synchronized (MyLock.objB) {
System.out.println("else objB");
synchronized (MyLock.objA) {
System.out.println("else objA");
}
}
}
}
}
生产者-消费者问题
线程间通信
针对同一个资源的操作有不同种类的线程。
举例:卖票有进的,也有出的。
案例:通过设置线程(生产者)和获取线程(消费者)针对同一个学生对象进行操作。
等待唤醒机制
Object类中提供了三个方法:
wait():等待。等待的时候会立即释放锁。将来醒过来的时候,是从该语句位置醒来,即从该位置继续执行。
notify():唤醒单个线程。唤醒并不意味着被唤醒的进程可以立马执行,还是需要抢CPU执行权。
notifyAll():唤醒所有线程。(用在多生产多消费中)
问题:为什么这些方法不定义在Thread类中呢?
这些方法的调用必须通过锁对象调用,而我们刚才使用的锁对象是任意锁对象。
所以,这些方法必须定义在Object类中。
/*
* 分析:
* 资源类:Student
* 设置学生数据:SetThread(生产者)
* 获取学生数据:GetThread(消费者)
* 测试类:StudentDemo
*
* 问题1:按照思路写代码,发现数据每次都是:null---0
* 原因:我们在每个线程中都创建了新的资源,而我们要求的时候设置和获取线程的资源应该是同一个
* 如何实现呢?
* 在外界把这个数据创建出来,通过构造方法传递给其他的类。
*
* 问题2:为了数据的效果好一些,我加入了循环和判断,给出不同的值,这个时候产生了新的问题
* A:同一个数据出现多次
* B:姓名和年龄不匹配
* 原因:
* A:同一个数据出现多次
* CPU的一点点时间片的执行权,就足够你执行很多次。
* B:姓名和年龄不匹配
* 线程运行的随机性
* 线程安全问题:
* A:是否是多线程环境 是
* B:是否有共享数据 是
* C:是否有多条语句操作共享数据 是
* 解决方案:
* 加锁。
* 注意:
* A:不同种类的线程都要加锁。
* B:不同种类的线程加的锁必须是同一把。
*
* 问题3:虽然数据安全了,但是呢,一次一大片不好看,我就想依次的一次一个输出。
* 如何实现呢?
* 通过Java提供的等待唤醒机制解决。
*
* 等待唤醒:
* Object类中提供了三个方法:
* wait():等待
* notify():唤醒单个线程
* notifyAll():唤醒所有线程
* 为什么这些方法不定义在Thread类中呢?
* 这些方法的调用必须通过锁对象调用,而我们刚才使用的锁对象是任意锁对象。
* 所以,这些方法必须定义在Object类中。
*/
public class StudentDemo {
public static void main(String[] args) {
//创建资源
Student s = new Student();
//设置和获取的类
SetThread st = new SetThread(s);
GetThread gt = new GetThread(s);
//线程类
Thread t1 = new Thread(st);
Thread t2 = new Thread(gt);
//启动线程
t1.start();
t2.start();
}
}
public class Student {
String name;
int age;
boolean flag; // 默认情况是没有数据,如果是true,说明有数据
}
public class SetThread implements Runnable {
private Student s;
private int x = 0;
public SetThread(Student s) {
this.s = s;
}
@Override
public void run() {
while (true) {
synchronized (s) {
//判断有没有
if(s.flag){
try {
s.wait(); //t1等着,释放锁
} catch (InterruptedException e) {
e.printStackTrace();
}
}
if (x % 2 == 0) {
s.name = "林青霞";
s.age = 27;
} else {
s.name = "刘意";
s.age = 30;
}
x++; //x=1
//修改标记
s.flag = true;
//唤醒线程
s.notify(); //唤醒t2,唤醒并不表示你立马可以执行,必须还得抢CPU的执行权。
}
//t1有,或者t2有
}
}
}
public class GetThread implements Runnable {
private Student s;
public GetThread(Student s) {
this.s = s;
}
@Override
public void run() {
while (true) {
synchronized (s) {
if(!s.flag){
try {
s.wait(); //t2就等待了。立即释放锁。将来醒过来的时候,是从这里醒过来的时候
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(s.name + "---" + s.age);
//林青霞---27
//刘意---30
//修改标记
s.flag = false;
//唤醒线程
s.notify(); //唤醒t1
}
}
}
}
线程的状态转换图
代码改进
在目前书写的消费者-生产者代码中,学生资源类的属性都是默认的,在实际书写中一般将其用private修饰,所以此处改进。同时由于用private修饰了属性,在类外我们就不能直接对其操作了,应该在Student类中提供相应的Set()和Get()方法。那么这个时候应该怎么同步呢?怎么样才能达到我们预期的效果?(即生产一个消费一个依次循环)
public class StudentDemo {
/**
* @param args
*/
public static void main(String[] args) {
Student s = new Student();
SetThread st = new SetThread(s);
GetThread gt = new GetThread(s);
Thread t1 = new Thread(st);
Thread t2 = new Thread(gt);
t1.start();
t2.start();
}
}
// 学生资源类
public class Student {
private String name;
private int age;
private boolean flag;
public Student() {
}
public synchronized void Set(String name, int age){
if(this.flag){
try {
this.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
this.name = name;
this.age = age;
this.flag = true;
this.notify();
}
public synchronized void Get(){
if(!this.flag){
try {
this.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
System.out.println(name + "---" + age);
this.flag = false;
this.notify();
}
}
// 生产者
public class SetThread implements Runnable {
private int x = 0;
private Student s;
public SetThread(Student s) {
this.s = s;
}
@Override
public void run() {
while(true){
if(x % 2 == 0){
s.Set("林青霞", 27);
}else{
s.Set("刘意", 30);
}
x++;
}
}
}
// 消费者
public class GetThread implements Runnable {
private Student s;
public GetThread(Student s) {
this.s = s;
}
@Override
public void run() {
while(true){
s.Get();
}
}
}
在之前的实现中,我们是在SetThread(生产者)和GetThread(消费者)类中,对需要同步的代码块,使用Student对象,进行同步。现在我们可以直接在Student类中对其Set()和Get()方法使用同步关键字。要想达成生产一个消费一个效果,像之前一样,用flag结合等待唤醒机制即可。