Java多线程信息共享(volatile,synchronized,Lock)

信息共享

• 粗粒度:子线程与子线程之间、和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关键字有两种使用方式

  1. 同步代码块
synchronized (对象){
// 需要被同步的代码;
}
  1. 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);

方式二:同步方法。
如果操作共享数据的代码完整的声明在一个方法中,我们不妨将此方法声明同步的。
关于同步方法的总结:

  1. 同步方法仍然涉及到同步监视器,只是不需要我们显式的声明。

  2. 非静态的同步方法,同步监视器是: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 的对比

  1. Lock是显式锁(手动开启和关闭锁,别忘记关闭锁),synchronized是隐式锁,出了作用域自动释放

  2. Lock只有代码块锁,synchronized有代码块锁和方法锁

  3. 使用Lock锁,JVM将花费较少的时间来调度线程,性能更好。并且具有更好的扩展性(提供更多的子类)

优先使用顺序:
Lock =>同步代码块(已经进入了方法体,分配了相应资源)=>同步方法(在方法体之外)

已标记关键词 清除标记
©️2020 CSDN 皮肤主题: 护眼 设计师:闪电赇 返回首页