- 概念
- 线程同步
- 锁机制
- 死锁问题
- 线程通信
- 生产者/消费者问题
多线程是指程序当中包含多个执行单元,即在一个程序中可以同时运行多个不同的线程来执行不同的任务,也就是说允许单个线程创建多个并行执行的线程来完成各自的任务。
何时需要多线程
程序需要同时执行两个或多个任务。
程序需要实现一些需要等待的任务时,如用户输入、文件读写操作、网络操作、搜索等。
需要一些后台运行的程序时。
多线程的优点
提高程序的响应
提高CPU的利用率
改善程序的结构,将复杂的任务分为多个线程,独立运行。
多线程的缺点
线程也是程序,所以线程也是需要占用内存,线程越多占用内存也是越多的。
多线程是需要协调和管理,所以这也是需要CPU时间跟踪线程的。
线程之间对共享资源的访问会互相影响,必须解决竞用共享资源的问题。
线程同步先看下面的一段代码:
在这样的输出绝对是有问题的。
所以在处理多线程的问题时,多个线程访问同一个对象,并且某些线程还想修改这个对象。这时候我们就需要线程的同步。线程同步其实就是一种等待机制,多个需要同时访问此对象的线程进入这个对象的等待池形成队列,等待前面的线程使用完毕,下一个线程再使用。
由于同一进程的多个线程共享同一块存储空间,在带来方便的同时,也带来了访问冲突的问题,为了保证数据在方法中被访问的正确性,在访问时加入锁机制synchronized,在当一个线程获得对象的排他锁,独占资源,其他线程必须等待,使用后释放锁即可。
这里也存在下面的问题:
- 一个线程持有锁会导致其他所有需要此锁的线程挂起。
- 在多线程竞争下,加锁,释放锁会导致比较多的上下文切换和调度延迟,引起性能问题。
- 如果一个优先级高的线程等待的线程等待一个优先级低的线程释放锁会导致优先级倒置,引起性能问题。
在Java中实现同步
使用synchronized(同步监视器)这个关键字来同步方法或代码块
synchronized(同步监视器){
}
synchionized还可以放在方法声明中,表示整个方法,为同步方法。
public synchionized void show(Sting name){
//需要同步的代码
}
同步代码块,执行完毕后,同步对象(锁)就会自动释放
当然在synchronized的时候,也可以直接传进去关键字this,表示当前的。只要表示出唯一性就可以了。
同步方法:
public class TicketThread implements Runnable {
static int num = 10;
@Override
public void run() {
while (true) {
if (num > 0) {
print();
} else {
break;
}
}
}
//在修饰方法的时候,同步对象(锁),默认的是this,一旦创建多个线程对象就崔出现一些问题(只针对继承Thread类的方式)
public synchronized void print() {
if (num > 0) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "售出票:" + num);
num--;
}
}
}
当然上面写的都是实现Runnable接口来实现的。
当然还是可以继承Thread类来实现的,在用thread来写的时候,一定要注意好只能由1个来实现的,该加static的时候就要加static来修饰,使得虽然创建了多个,但实际只能还是一个存在的。
上面代码中有提到的同步监视器是什么呢?
同步监视器可以是任何对象,但必须保证唯一,保证多个线程获得的是同一个对象(锁)
同步监视器的执行过程:
- 第一个线程访问,就锁定同步监视器,执行其中的代码
- 第二个线程访问,发现同步监视器被锁定的话,就无发访问
- 第一个线程结束访问,就解锁了同步监视器。
- 第二个线程访问,发现同步监视器没有锁,就可能正常访问,并加锁。
上面提到的synchronized就是一个隐式的加锁,释放锁。
在这提到到的Lock是可以显示的加锁,释放锁的,但只能锁定代码块。
Lock:
是从jdk 1.5开始的,Java提供了更强大的线程同步机制-通过显示的定义同步锁对象来实现同步。同步锁使用Lock对象充当。
java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独立访问,每次只能有一个线程对Lock对象加锁,线程开始访问共享资源之前应先获得Lock对象。
ReentrantLock类实现了Lock,它拥有与synchronized相同的并发性和内存语义,在实现线程安全的控制中,比较常用的是ReentranlLock,可以显示加锁,释放锁。
对我们上面写的TicketThread类的代码做做修改:
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class TicketThread implements Runnable {
static int num = 10;
Lock lock = new ReentrantLock();//创建Lock锁
@Override
public void run() {
while (true) {
if (num > 0) {
print();
} else {
break;
}
}
}
public void print() {
try {
lock.lock();//加锁
if (num > 0) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "售出票:" + num);
num--;
}
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();//在finally释放锁
}
}
}
死锁问题
什么是死锁?
就是在不同的线程分别占用对方需要的同步资源而不放手,都在等待对方先放弃自己需要的同步资源,就形成了线程的死锁。
在出现死锁的时候,是不会报异常的,也不会出现提示,只是所有的线程都处在阻塞状态,无法继续。
举个例子:
中国人和美国人吃饭
在正常情况下:中国人:两个筷子;美国热:刀和叉
不正常情况下:中国人:一个筷子一把刀;美国热:一个筷子一把叉子
在这样的环境下,就形成了死锁问题。
所以在设计的时候就要考虑清楚锁的顺序,尽量减少嵌套的加锁交互数量。
来个代码演示一下这个死锁问题:
public class Demo07 {
public static void main(String[] args) {
DieLock dieLock1 = new DieLock(true);
DieLock dieLock2 = new DieLock(false);
dieLock1.start();
dieLock2.start();
}
}
class DieLock extends Thread {
static Object objA = new Object();
static Object objB = new Object();
boolean flag;
public DieLock(boolean flag) {
this.flag = flag;
}
@Override
public void run() {
if (flag) {
synchronized (objA) {
System.out.println("ifObjA");
synchronized (objB) {
System.out.println("ifObjB");
}
}
} else {
synchronized (objB) {
System.out.println("elseObjB");
synchronized (objA) {
System.out.println("elseObjA");
}
}
}
}
}
执行这个代码就有很大可能造成死锁问题,就是A锁和B锁同时在用,但是在A锁和B锁的里面又要用到互相的锁,但是都被占用着,就造成了,两方都互不相容的结局,使得代码卡死在这里。
线程通信指的是多个线程通过消息传递实现相互牵制,相互调度,即线程间的相互作用。
在这设计到三个方法:
.wait 一旦执行此方法,当前线程就进入阻塞状态,并释放同步监视器
.notify 一旦执行此方法,就会唤醒被wait的一个线程。如果有多个线程被wait了,就唤醒优先级最高的那个。
.notifAll 执行此方法,就唤醒所有被wait的方法。
注意:
.wait、.notif、.notifyAll 三个方法都必须使用在同步代码块或同步方法中。
并且这三个方法都是定义在java.lang.Object类当中。
代码演示一个例子(两个线程交替打印1-15之间的数字)
public class Demo08 {
public static void main(String[] args) {
PrintNum p1 = new PrintNum();
PrintNum p2 = new PrintNum();
p1.setName("PrintNum1");
p2.setName("PrintNum2");
p1.start();
p2.start();
}
}
class PrintNum extends Thread{
static int num= 0;
static Object obj = new Object();
@Override
public void run() {
while (true){
synchronized (obj){
//在执行当前线程的时候,唤醒等待的线程,由于已经有线程在执行,也是不能进入到同步的代码块当中
obj.notify();
if (num < 15){
num++;
System.out.println(Thread.currentThread().getName()+":"+num);
}else {
break;
}
try {
obj.wait();//将当前线程等待,并释放当前线程
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
最后的结果也是按照我们的预想,在进行交替打印进行。
生产者/消费者问题生产者(Producer)将产品放在柜台(Counter),而消费者(Customer)从柜台 处取走产品,生产者一次只能生产固定数量的产品(比如:1), 这时柜台中不能再放产品,此时生产者应停止生产等待消费者拿走产品,此时生产者唤醒消费者来取走产品,消费者拿走产品后,唤醒生产者,消费者开始等待。
class Counter {
static int num = 0;
public synchronized void add() {
if (num == 0) {
num++;
System.out.println("生产者线程现在生产一个");
this.notify();//这里直接使用,就是因为java中所有的类最终都继承自Object类,所以直接使用。
} else {
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public synchronized void sub() {
if (num > 0) {
num--;
System.out.println("消费者线程现在消费一个");
this.notify();
} else {
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
class ProducerThread extends Thread {
Counter counter;
public ProducerThread(Counter counter) {
this.counter = counter;
}
@Override
public void run() {
while (true) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
counter.add();
}
}
}
class CustomerThread extends Thread {
Counter counter;
public CustomerThread(Counter counter) {
this.counter = counter;
}
@Override
public void run() {
while (true) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
counter.sub();
}
}
}
public class Demo09 {
public static void main(String[] args) {
Counter c = new Counter();//两个线程贡献的资源,柜台
ProducerThread producerThread = new ProducerThread(c);
CustomerThread customerThread = new CustomerThread(c);
producerThread.start();
customerThread.start();
}
}
下一篇: ===》 Java中的线程



