信息共享

• 粗粒度：子线程与子线程之间、和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 =>同步代码块（已经进入了方法体，分配了相应资源）=>同步方法（在方法体之外）

Java多线程信息共享（volatile，synchronized，Lock）