Java多线程入门(二)
会当凌绝顶，一览众山小
| @Author：TTODS
目录
- Java多线程入门（二）
- 线程同步
- 为什么要线程同步?
- 线程同步的三个方法
- 线程死锁
- 线程的生命周期
Java多线程入门（二）
线程同步
为什么要线程同步?
使用多线程可以让我们的程序更加充分的利用CPU,提高程序的效率,但是同时也带来了一些问题。多线程在使用线程公共资源的时候往往会遇到问题。
想象一下这样一个情景:一个商店中有三件商品，但是四个顾客同时来购买商品，他们都能买到商品吗？
我们用代码模拟一下:
public class Test{
public static void main(String[] args) {
//创建一个商店
Store store = new Store();
//创建四个共用一个商店的顾客线程
CustomerThread ct1 = new CustomerThread("顾客1",store);
CustomerThread ct2 = new CustomerThread("顾客2",store);
CustomerThread ct3 = new CustomerThread("顾客3",store);
CustomerThread ct4 = new CustomerThread("顾客4",store);
//启动四个线程
ct1.start();
ct2.start();
ct3.start();
ct4.start();
}
}
//商店类
class Store {
//剩余商品数量
static int goodsNumble = 3;
public Store(){
}
//出售一件商品
void sell() {
//先判断商品是否售完
if(goodsNumble<=0)
System.out.println("商店:出售失败,商品卖完了");
else {
System.out.println("此时还有"+goodsNumble+"件商品");
goodsNumble--;
System.out.println("售出一件商品,商品数量减1");
}
}
}
class CustomerThread extends Thread{
private Store store;
public CustomerThread(String name,Store store) {
// TODO 自动生成的构造函数存根
setName(name);
this.store = store;
}
@Override
public void run() {
buy();
}
//购买商品,调用store的sell方法
public void buy() {
store.sell();
}
}
运行结果
从上面的代码和运行结果我们可以看到，因为顾客几乎是同时到达商店的，所以他们到的时候商品的水量都是3,于是商店给每一位顾客都出售了一件商品。这显然不是我们想要的结果。然后我们给Store类的sell()方法加上synchronized关键字，局部修改如下:
synchronized void sell() {
//先判断商品是否售完
if(goodsNumble<=0)
System.out.println("商店:出售失败,商品卖完了");
else {
System.out.println("此时还有"+goodsNumble+"件商品");
goodsNumble--;
System.out.println("售出一件商品,商品数量减1");
}
}
运行结果：
可以看到在我们给sell方法使用了synchronized关键字后Stroe会按照一定的顺序来为顾客服务,这就是synchronized方法的效果.当当前线程使用synchronized方法时，会给当前对象(store)上锁，上锁后其他线程在使用相同对象的方法时进入阻塞,需等待此线程中的该方法结束，才能继续运行。
线程同步的三个方法
为了介绍线程同步的三个方法，我们先来看一下这样一个场景：有一个房间，房间里居住着四个人，四个人共用着房间里的一部电话。每个人都可以在任何时候使用电话，但是如果他们在同一时间都来使用这部电话又会发生什么呢？
我们用代码模拟一下:
public class SynchronizedMethod {
public static void main(String[] args) {
Room r = new Room();
//创建并启动4个学生线程
StudentThread s1 =new StudentThread("s1",r);
StudentThread s2 =new StudentThread("s2",r);
StudentThread s3 =new StudentThread("s3",r);
StudentThread s4 =new StudentThread("s4",r);
s1.start();
s2.start();
s3.start();
s4.start();
}
}
class Room {
public Phone phone;
public Room() {
// TODO 自动生成的构造函数存根
phone = new Phone();
}
}
class Phone{
static final int FREE = 1,BUSY = 0;
//电话的状态
private int status=FREE;
public Phone() {
}
//判断电话是否空闲
public boolean isFree() {
return status==FREE;
}
//打电话，半秒后挂断,为了打印电话使用者的名字，我们传入一个参数
public void call(String user) {
if(!isFree()) {
System.out.println("有人正在使用电话哦");
return;
}
status = BUSY;
System.out.println(user+"打出了电话...");
try {
Thread.sleep(500);
hangUp(user);
} catch (InterruptedException e) {
// TODO 自动生成的 catch 块
e.printStackTrace();
}
}
//挂电话
public void hangUp(String user) {
status = Phone.FREE;
System.out.println(user+"挂断了电话...");
}
}
class StudentThread extends Thread{
private Room room;
public StudentThread(String name,Room room) {
setName(name);
this.room = room;
}
@Override
public void run() {
this.room.phone.call(getName());
}
}
运行结果
我们可以发现当线程s1使用了对象phone的call方法的时候，其他三个线程仍然使用了call方法。这就是线程不同步的效果。接下来我们分别用三种方法实现线程同步。
synchronized方法
将Phone类的call声明为sychronized方法(在call方法前面加上关键字即可)，修改部分代码如下:
public synchronized void call(String user) {
if(!isFree()) {
System.out.println("有人正在使用电话哦");
return;
}
status = BUSY;
System.out.println(user+"打出了电话...");
try {
Thread.sleep(500);
hangUp(user);
} catch (InterruptedException e) {
// TODO 自动生成的 catch 块
e.printStackTrace();
}
}
运行结果
synchronized块
在call函数内添加synchronized代码块,此方法与上一方法相比，优点在于你不需将整个方法都变成同步的，只需把关键代码块变为同步即可,修改部分代码如下:
public void call(String user) {
synchronized (this) {
if(!isFree()) {
System.out.println("有人正在使用电话哦");
return;
}
status = BUSY;
System.out.println(user+"打出了电话...");
try {
Thread.sleep(500);
hangUp(user);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
运行结果
- Lock
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
class Phone{
private Lock lock= new ReentrantLock();
static final int FREE = 1,BUSY = 0;
//电话的状态
private int status=FREE;
public Phone() {
}
//判断电话是否空闲
public boolean isFree() {
return status==FREE;
}
//打电话，半秒后挂断,为了打印电话使用者的名字，我们传入一个参数
public void call(String user) {
//上锁
lock.lock();
if(!isFree()) {
System.out.println("有人正在使用电话哦");
return;
}
status = BUSY;
System.out.println(user+"打出了电话...");
try {
Thread.sleep(500);
hangUp(user);
} catch (InterruptedException e) {
e.printStackTrace();
}
//释放锁
lock.unlock();
}
//挂电话
public void hangUp(String user) {
status = Phone.FREE;
System.out.println(user+"挂断了电话...");
}
}
运行结果
线程死锁
线程死锁，是指多个线程在使用公共资源时各占了资源的一部分，导致每个线程都等待其他线程释放资源才能完成工作，最终导致每个线程都无法完成工作，互相卡死。
想象一下这样的情景:上学时，你和你的同桌共用一个笔记本和一支钢笔，只是你的老师讲到了一个要点，于是你顺势抢到了钢笔，而你的同桌拿到了笔记本，谁也不肯让步，于是谁也无法完成笔记。
我们用代码模拟一下：
public class DeadLock {
public static void main(String[] args) {
Stationery stationery = new Stationery();
//p1 takeNotes时先获取并锁定本子，然后再试图获取笔
Person p1 = new Person("p1",stationery) {
@Override
public void takeNotes() {
synchronized (stationery.notebook) {
getNotebook();
synchronized (stationery.pen) {
getPen();
}
}
}
};
//p2 takeNotes时先获取并锁定笔，然后再试图获取本子
Person p2 = new Person("p2",stationery) {
@Override
public void takeNotes() {
synchronized (stationery.pen) {
getPen();
synchronized (stationery.notebook) {
getNotebook();
}
}
}
};
p1.start();
p2.start();
}
}
//文具类(共用资源)
class Stationery{
//笔
public static Pen pen = new Pen();
//笔记本
public static Notebook notebook= new Notebook();
}
class Pen{
}
class Notebook{
}
abstract class Person extends Thread{
Stationery stationery;
public Person(String name,Stationery s) {
// TODO 自动生成的构造函数存根
setName(name);
stationery = s;
}
//获取笔
Pen getPen() {
System.out.println(getName()+":我拿打笔了");
try {
Thread.sleep(1);
} catch (InterruptedException e) {
// TODO 自动生成的 catch 块
e.printStackTrace();
}
return stationery.pen;
};
//获取本子
Notebook getNotebook() {
System.out.println(getName()+":我拿打笔记本了");
try {
Thread.sleep(1);
} catch (InterruptedException e) {
// TODO 自动生成的 catch 块
e.printStackTrace();
}
return stationery.notebook;
};
//抽象方法
public abstract void takeNotes();
@Override
public void run() {
takeNotes();
};
}
运行结果(程序并没有结束而是一直卡住无法往下运行)
线程的生命周期
- 新建态 ：
Thread t = new Thread()，线程对象被创建，此时还没有使用start()方法，启动线程 - 就绪状态 ：
t.start()后进入就绪状态，但具体什么时候运行取决于CPU的调度 - 运行态：线程占用CPU运行
- 阻塞态：线程在运行时，使用了
Thread.sleep()或者进行I/O操作等不在占用CPU,则由运行态进入阻塞态，待事件结束再进入就绪态 t.stop()线程结束，进入终止态(消亡状态)