信息共享
• 粗粒度:子线程与子线程之间、和main线程之间缺乏交流
• 细粒度:线程之间有信息交流通讯
– 通过共享变量达到信息共享
– JDK原生库暂不支持发送消息 (类似MPI并行库直接发送消息)
• 通过共享变量在多个线程中共享消息
– static变量
– 同一个Runnable类的成员变量
• 多线程信息共享问题
– 工作缓存副本
– 关键步骤缺乏加锁限制
• i++,并非原子性操作
– 读取主存i (正本)到工作缓存(副本)中
– 每个CPU执行(副本)i+1操作
– CPU将结果写入到缓存(副本)中
– 数据从工作缓存(副本)刷到主存(正本)中
变量副本问题的解决方法(volatile)
– 采用volatile 关键字修饰变量(用volatile修饰的变量可以及时在各线程里面通知)
– 保证不同线程对共享变量操作时的可见性
public class ThreadDemo2
{
public static void main(String args[]) throws Exception
{
TestThread2 t = new TestThread2();
t.start();
Thread.sleep(2000);
t.flag = false;
System.out.println("main thread is exiting");
}
}
class TestThread2 extends Thread
{
//boolean flag = true; //子线程不会停止
volatile boolean flag = true; //用volatile修饰的变量可以及时在各线程里面通知
public void run()
{
int i=0;
while(flag)
{
i++;
}
System.out.println("test thread3 is exiting");
}
}
关键步骤加锁限制(synchronized)
临界资源和互斥锁
多个线程间共享的数据称为临界资源(Critical Resource)
每个对象都有一个“互斥锁”标记,保证在任何时刻只能有一个线程访问该对象。
Java中用synchronized来标记对象在任意时刻该对象只能被一个线程访问。
synchronized关键字有两种使用方式
- 同步代码块:
synchronized (对象){
// 需要被同步的代码;
}
- synchronized还可以放在方法声明中,表示整个方法为同步方法。例如:
public synchronized void show (String name){
….
}
Runnable接口的方式解决线程安全
方式一:同步代码块
说明:
1.操作共享数据的代码,即为需要被同步的代码。 -->不能包含代码多了,也不能包含代码少了。
2.共享数据:多个线程共同操作的变量。
3.同步监视器,俗称:锁。任何一个类的对象,都可以充当锁。
要求:多个线程必须要共用同一把锁。
补充:在实现Runnable接口创建多线程的方式中,我们可以考虑使用this充当同步监视器。
(用本类的对象作监视器,当然也可以使用其他任何对象)
class Window1 implements Runnable{
private int ticket = 100;
// Object obj = new Object();
// Dog dog = new Dog();
@Override
public void run() {
// Object obj = new Object();
while(true){
synchronized (this){
//此时的this:唯一的Window1的对象
//方式二:synchronized (dog) {
if (ticket > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + ":卖票,票号为:" + ticket);
ticket--;
} else {
break;
}
}
}
}
}
Window1 w = new Window1();
Thread t1 = new Thread(w);
Thread t2 = new Thread(w);
Thread t3 = new Thread(w);
方式二:同步方法。
如果操作共享数据的代码完整的声明在一个方法中,我们不妨将此方法声明同步的。
关于同步方法的总结:
-
同步方法仍然涉及到同步监视器,只是不需要我们显式的声明。
-
非静态的同步方法,同步监视器是:this
静态的同步方法,同步监视器是:当前类本身
@Override
public void run() {
while (true) {
show();
}
}
private synchronized void show(){
//同步监视器:this
//synchronized (this)**可以使用{
if (ticket > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + ":卖票,票号为:" + ticket);
ticket--;
}
//}
}
继承Thread类的方式解决线程安全
注意:加静态()
方式一:代码块
说明:在继承Thread类创建多线程的方式中,慎用this充当同步监视器,考虑使用当前类充当同步监视器。(this代表着t1,t2,t3三个对象)
class Window2 extends Thread {
private static int ticket = 100;
private static Object obj = new Object();
@Override
public void run() {
while (true) {
//正确的
// synchronized (obj){
synchronized (Window2.class) {
//Class clazz = Window2.class,Window2.class只会加载一次
//错误的方式:this代表着t1,t2,t3三个对象
// synchronized (this){
if (ticket > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(getName() + ":卖票,票号为:" + ticket);
ticket--;
} else {
break;
}
}
}
}
}
Window2 t1 = new Window2();
Window2 t2 = new Window2();
Window2 t3 = new Window2();
使用同步方法处理继承Thread类的方式中的线程安全问题
@Override
public void run() {
while (true) {
show();
}
}
private static synchronized void show(){
//同步监视器:Window4.class
//private synchronized void show(){ //同步监视器:t1,t2,t3。此种解决方式是错误的
if (ticket > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + ":卖票,票号为:" + ticket);
ticket--;
}
}
同步锁机制:
在《Thinking in Java》中,是这么说的:对于并发工作,你需要某种方式来防止两个任务访问相同的资源(其实就是共享资源竞争)。 防止这种冲突的方法就是当资源被一个任务使用时,在其上加锁。第一个访问某项资源的任务必须锁定这项资源,使其他任务在其被解锁之前,就无法访问它了,而在其被解锁之时,另一个任务就可以锁定并使用它了。
synchronized的锁是什么?
-
任意对象都可以作为同步锁。所有对象都自动含有单一的锁(监视器)。
-
同步方法的锁:静态方法(类名.class)、非静态方法(this)
-
同步代码块:自己指定,很多时候也是指定为this或类名.class
注意:
-
必须确保使用同一个资源的多个线程共用一把锁,这个非常重要,否则就无法保证共享资源的安全
-
一个线程类中的所有静态方法共用同一把锁(类名.class),所有非静态方法共用同一把锁(this),同步代码块(指定需谨慎)
同步的范围
1、如何找问题,即代码是否存在线程安全?(非常重要)
(1) 明确哪些代码是多线程运行的代码
(2) 明确多个线程是否有共享数据
(3) 明确多线程运行代码中是否有多条语句操作共享数据
2、如何解决呢?(非常重要)
对多条操作共享数据的语句,只能让一个线程都执行完,在执行过程中,其他线程不可以参与执行。即所有操作共享数据的这些语句都要放在同步范围中
3、切记:
-
范围太小:没锁住所有有安全问题的代码
-
范围太大:没发挥多线程的功能。
释放锁的操作
- 当前线程的同步方法、同步代码块执行结束。
- 当前线程在同步代码块、同步方法中遇到break、return终止了该代码块、该方法的继续执行。
- 当前线程在同步代码块、同步方法中出现了未处理的Error或Exception,导致异常结束。
- 当前线程在同步代码块、同步方法中执行了线程对象的
wait()
方法,当前线程暂停,并释放锁。
不会释放锁的操作
-
线程执行同步代码块或同步方法时,程序调用
Thread.sleep()
、Thread.yield()
方法暂停当前线程的执行 -
线程执行同步代码块时,其他线程调用了该线程的
suspend()
方法将该线程挂起,该线程不会释放锁(同步监视器)。
应尽量避免使用suspend()和resume()来控制线程
Lock(锁)
-
从JDK 5.0开始,Java提供了更强大的线程同步机制——通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当。
-
java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问,每次只能有一个线程对Lock对象加锁,线程开始访问共享资源之前应先获得Lock对象。
-
ReentrantLock 类实现了 Lock ,它拥有与 synchronized 相同的并发性和内存语义,在实现线程安全的控制中,比较常用的是ReentrantLock,可以显式加锁、释放锁。
synchronized 与 Lock 的对比
-
Lock是显式锁(手动开启和关闭锁,别忘记关闭锁),synchronized是隐式锁,出了作用域自动释放
-
Lock只有代码块锁,synchronized有代码块锁和方法锁
-
使用Lock锁,JVM将花费较少的时间来调度线程,性能更好。并且具有更好的扩展性(提供更多的子类)
优先使用顺序:
Lock =>同步代码块(已经进入了方法体,分配了相应资源)=>同步方法(在方法体之外)