第三章 - 共享模型之管程(一)

文章目录

第三章 - 共享模型之管程(一)
本章内容
共享带来的问题
方法上的 synchronized
- 不加 synchronized 的方法
- 所谓的“线程八锁”
变量的线程安全分析
习题

本章内容

共享问题
synchronized
线程安全分析
Monitor
wait/notify
线程状态转换
活跃性
Lock

共享带来的问题

小故事

老王（操作系统）有一个功能强大的算盘（CPU），现在想把它租出去，赚一点外快

Untitled

小南、小女（线程）来使用这个算盘来进行一些计算，并按照时间给老王支付费用
但小南不能一天24小时使用算盘，他经常要小憩一会（sleep），又或是去吃饭上厕所（阻塞 io 操作），有时还需要一根烟，没烟时思路全无（wait）这些情况统称为（阻塞）

Untitled

在这些时候，算盘没利用起来（不能收钱了），老王觉得有点不划算
另外，小女也想用用算盘，如果总是小南占着算盘，让小女觉得不公平
于是，老王灵机一动，想了个办法 [ 让他们每人用一会，轮流使用算盘 ]
这样，当小南阻塞的时候，算盘可以分给小女使用，不会浪费，反之亦然
最近执行的计算比较复杂，需要存储一些中间结果，而学生们的脑容量（工作内存）不够，所以老王申请了一个笔记本（主存），把一些中间结果先记在本上
计算流程是这样的

Untitled

但是由于分时系统，有一天还是发生了事故
小南刚读取了初始值 0 做了个 +1 运算，还没来得及写回结果
老王说 [ 小南，你的时间到了，该别人了，记住结果走吧 ]，于是小南念叨着 [ 结果是1，结果是1…] 不甘心地到一边待着去了（上下文切换）
老王说 [ 小女，该你了 ]，小女看到了笔记本上还写着 0 做了一个 -1 运算，将结果 -1 写入笔记本
这时小女的时间也用完了，老王又叫醒了小南：[小南，把你上次的题目算完吧]，小南将他脑海中的结果 1 写入了笔记本

Untitled

小南和小女都觉得自己没做错，但笔记本里的结果是 1 而不是 0

由故事引发的Java代码的体现

@Slf4j(topic = "c.Test17")
public class Test17 {
    static int count = 0;

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 5000; i++) {
                count++;
            }
        }, "t1");

        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 5000; i++) {
                count--;
            }
        }, "t2");

        t1.start();
        t2.start();
        t1.join();
        t2.join();
        log.debug("{}", count);
    }

}

Untitled

问题分析

以上的结果可能是正数、负数、零。为什么呢？因为 Java 中对静态变量的自增，自减并不是原子操作，要彻底理解，必须从字节码来进行分析
例如对于 i++ 而言（i 为静态变量），实际会产生如下的 JVM 字节码指令：

Untitled

而对应 i-- 也是类似：

Untitled

而 Java 的内存模型如下，完成静态变量的自增，自减需要在主存和工作内存中进行数据交换：

Untitled

如果是单线程以上 8 行代码是顺序执行（不会交错）没有问题：

Untitled

出现负数的情况：

Untitled

出现正数的情况：

Untitled

临界区 Critical Section

一个程序运行多个线程本身是没有问题的
问题出在多个线程访问共享资源
- 多个线程读共享资源其实也没有问题
- 在多个线程对共享资源读写操作时发生指令交错，就会出现问题
一段代码块内如果存在对共享资源的多线程读写操作，称这段代码块为临界区

static int counter = 0;

static void increment() 
// 临界区
{ 
	counter++; 
}

static void decrement() 
// 临界区
{ 
	counter--; 
}

竞态条件 Race Condition

多个线程在临界区内执行，由于代码的执行序列不同而导致结果无法预测，称之为发生了竞态条件

synchronized 解决方案

为了避免临界区的竞态条件发生，有多种手段可以达到目的。

阻塞式的解决方案：synchronized，Lock
非阻塞式的解决方案：原子变量

本次使用阻塞式的解决方案：synchronized，来解决上述问题，即俗称的【对象锁】，它采用互斥的方式让同一时刻至多只有一个线程能持有【对象锁】，其它线程再想获取这个【对象锁】时就会阻塞住。这样就能保证拥有锁的线程可以安全的执行临界区内的代码，不用担心线程上下文切换

synchronized

synchronized(对象) // 线程1， 线程2(blocked)
{
	临界区
}

public class Test17 {
    static int count = 0;
    static final Object room = new Object();
    
  public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 5000; i++) {
                synchronized (room){
                    count++;
                }
            }
        }, "t1");

        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 5000; i++) {
                synchronized (room){
                    count--;
                }
            }
        }, "t2");

        t1.start();
        t2.start();
        t1.join();
        t2.join();
        log.debug("{}", count);
    }
}

Untitled

synchronized 原理分析

Untitled

synchronized(对象)中的对象，可以想象为一个房间（room），有唯一入口（门）房间只能一次进入一人进行计算，线程 t1，t2 想象成两个人
当线程 t1 执行到 synchronized(room)时就好比 t1 进入了这个房间，并锁住了门拿走了钥匙，在门内执行count++ 代码
这时候如果 t2 也运行到了 synchronized(room) 时，它发现门被锁住了，只能在门外等待，发生了上下文切换，阻塞住了
这中间即使 t1 的 cpu 时间片不幸用完，被踢出了门外（不要错误理解为锁住了对象就能一直执行下去哦），这时门还是锁住的，t1 仍拿着钥匙，t2 线程还在阻塞状态进不来，只有下次轮到 t1 自己再次获得时间片时才能开门进入
当 t1 执行完 synchronized{ } 块内的代码，这时候才会从 obj 房间出来并解开门上的锁，唤醒 t2 线程并把钥匙给他。t2 线程这时才可以进入 obj 房间，锁住了门拿上钥匙，执行它的 count-- 代码

Untitled

思考

为了加深理解，请思考下面的问题

如果把 synchronized(obj) 放在 for 循环的外面，如何理解？-- 原子性
- 对整个循环内5000次操作都上锁了。保证了原子性
如果 t1 synchronized(obj1) 而 t2 synchronized(obj2) 会怎样运作？-- 锁对象
- 对象不同，相当于拿到的锁不同，不能保证原子性。
如果 t1 synchronized(obj) 而 t2 没有加会怎么样？如何理解？-- 锁对象
- 对于同一个共享资源，所有对其的操作都要加锁，不然t1加锁，但是t2不加锁，那么t2运行到临界区时，就不会去尝试拿锁，自然不会被阻塞。

面向对象改进

@Slf4j(topic = "c.Test17")
public class Test17 {

    public static void main(String[] args) throws InterruptedException {

        Room room = new Room();

        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 5000; i++) {
                room.increment();
            }
        }, "t1");

        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 5000; i++) {
                room.decrement();
            }
        }, "t2");

        t1.start();
        t2.start();
        t1.join(); //等待t1线程结束
        t2.join(); //等待t2线程结束
        log.debug("{}", room.getCounter());
    }

}

class Room {
    private int counter = 0;

    public void increment() {
        synchronized (this) {
            counter++;
        }
    }

    public void decrement() {
        synchronized (this) {
            counter--;
        }
    }

    public int getCounter() {
        synchronized (this) {
            return counter;
        }
    }

}

方法上的 synchronized

class Test{

	public synchronized void test() {
 
  }

}

// 等价于
class Test{

	public void test() {
		synchronized(this) { //锁住的是this对象
 		
    }
 	}

}

class Test{

  public synchronized static void test() {
 
  }

}

// 等价于
class Test{

  public static void test() {
    synchronized(Test.class) { //锁住的是Test类
      
    }
  }

}

不加 synchronized 的方法

不加 synchronzied 的方法就好比不遵守规则的人，不去老实排队（好比翻窗户进去的）

所谓的“线程八锁”

其实就是考察 synchronized 锁住的是哪个对象

@Slf4j(topic = "c.Test8Locks")
public class Test8Locks {

    public static void main(String[] args) {
        Number n1 = new Number();

        new Thread(() -> { //线程1
            log.debug("begin");
            n1.a();
        }).start();

        new Thread(() -> { //线程2
            log.debug("begin");
            n1.b();
        }).start();
    }

}

@Slf4j(topic = "c.Number")
class Number{

    public synchronized void a() { //锁住的是this对象
        log.debug("1");
    }

    public synchronized void b() { //锁住的是this对象
        log.debug("2");
    }

}

Untitled

@Slf4j(topic = "c.Test8Locks")
public class Test8Locks {

    public static void main(String[] args) {
        Number n1 = new Number();

        new Thread(() -> { //线程1
            log.debug("begin");
            n1.a();
        }).start();

        new Thread(() -> { //线程2
            log.debug("begin");
            n1.b();
        }).start();
    }

}

@Slf4j(topic = "c.Number")
class Number{

    public synchronized void a() {
        sleep(1);
        log.debug("1");
    }

    public synchronized void b() {
        log.debug("2");
    }

}

Untitled

a方法睡了1秒。
可能是线程1先拿到锁，执行a方法，但是睡了1秒，然后打印1，接着线程2拿到锁马上打印2。所以结果 1s后 1 2
可能线程2先拿到锁，执行b方法打印2，然后线程1拿到锁马上执行a方法，先睡1秒，然后打印1。所以结果2 1s后 1

@Slf4j(topic = "c.Test8Locks")
public class Test8Locks {

    public static void main(String[] args) {
        Number n1 = new Number();

        new Thread(() -> { //线程1
            log.debug("begin");
            n1.a();
        }).start();

        new Thread(() -> { //线程2
            log.debug("begin");
            n1.b();
        }).start();

        new Thread(() -> { //线程3
            log.debug("begin");
            n1.c();
        }).start();
    }

}

@Slf4j(topic = "c.Number")
class Number{

    public synchronized void a() {
        sleep(1);
        log.debug("1");
    }

    public synchronized void b() {
        log.debug("2");
    }

    public  void c() {
        log.debug("3");
    }

}

Untitled

c方法没有synchronized，不会被锁住，所以3一定会在1之前打印（因为1会先睡1秒）。
打印2或3的顺序不一定，看谁先分到时间片执行

@Slf4j(topic = "c.Test8Locks")
public class Test8Locks {

    public static void main(String[] args) {
        Number n1 = new Number();
        Number n2 = new Number();

        new Thread(() -> {
            log.debug("begin");
            n1.a();
        }).start();

        new Thread(() -> {
            log.debug("begin");
            n2.b();
        }).start();

    }

}

@Slf4j(topic = "c.Number")
class Number{

    public synchronized void a() { //锁住的是this对象
        sleep(1);
        log.debug("1");
    }

    public synchronized void b() { //锁住的是this对象
        log.debug("2");
    }

}

Untitled

两个方法锁的不是同一个对象，线程1锁住的是n1对象，线程2锁住的是n2对象。
由于线程1打印1之前始终要睡1s。而线程2由于不用等1的锁，所以可以直接打印2。所以始终是打印2的1s后打印1。

@Slf4j(topic = "c.Test8Locks")
public class Test8Locks {

    public static void main(String[] args) {
        Number n1 = new Number();

        new Thread(() -> {
            log.debug("begin");
            n1.a();
        }).start();

        new Thread(() -> {
            log.debug("begin");
            n1.b();
        }).start();

    }
}

@Slf4j(topic = "c.Number")
class Number{

    public static synchronized void a() { //锁住的是Number类对象
        sleep(1);
        log.debug("1");
    }

    public synchronized void b() { //锁住的是this对象
        log.debug("2");
    }

}

Untitled

a方法是static静态方法，锁住的对象是Number.class
b方法是成员方法，锁住的对象的this
两者锁的对象不同，所以两者是同时执行的，但由于a打印1之前始终要睡1s。所以结果为：2 1s后 1

@Slf4j(topic = "c.Test8Locks")
public class Test8Locks {

    public static void main(String[] args) {
        Number n1 = new Number();

        new Thread(() -> {
            log.debug("begin");
            n1.a();
        }).start();

        new Thread(() -> {
            log.debug("begin");
            n1.b();
        }).start();

    }
}

@Slf4j(topic = "c.Number")
class Number{

    public static synchronized void a() { //锁住的是Number类对象
        sleep(1);
        log.debug("1");
    }

    public static synchronized void b() { //锁住的是Number类对象
        log.debug("2");
    }

}

Untitled

a和b方法都是static静态方法，锁的对象都是Number.class
所以两者拿的是同一把锁

@Slf4j(topic = "c.Test8Locks")
public class Test8Locks {

    public static void main(String[] args) {
        Number n1 = new Number();
        Number n2 = new Number();

        new Thread(() -> {
            log.debug("begin");
            n1.a();
        }).start();

        new Thread(() -> {
            log.debug("begin");
            n2.b();
        }).start();

    }
}
@Slf4j(topic = "c.Number")
class Number{

    public static synchronized void a() { //锁住的是Number类对象
        sleep(1);
        log.debug("1");
    }

    public synchronized void b() { //锁住的是this对象
        log.debug("2");
    }

}

Untitled

a方法的锁为Number.class
b方法的锁为n2对象
两者的锁不同

@Slf4j(topic = "c.Test8Locks")
public class Test8Locks {

    public static void main(String[] args) {
        Number n1 = new Number();
        Number n2 = new Number();

        new Thread(() -> {
            log.debug("begin");
            n1.a();
        }).start();

        new Thread(() -> {
            log.debug("begin");
            n2.b();
        }).start();

    }
}
@Slf4j(topic = "c.Number")
class Number{

    public static synchronized void a() { //锁住的是Number类对象
        sleep(1);
        log.debug("1");
    }

    public static synchronized void b() { //锁住的是Number类对象
        log.debug("2");
    }

}

Untitled

a方法的锁为Number.class，b方法的锁也为Number.class
虽然是通过n1、n2两个不同的对象调用，但是类只有一种。所以还是同一把锁

变量的线程安全分析

成员变量和静态变量是否线程安全？

如果它们没有共享，则线程安全
如果它们被共享了，根据它们的状态是否能够改变，又分两种情况
- 如果只有读操作，则线程安全
- 如果有读写操作，则这段代码是临界区，需要考虑线程安全

局部变量是否线程安全？

局部变量是线程安全的
但局部变量引用的对象（也可以被其他引用）则未必
- 如果该对象没有逃离方法的作用访问，它是线程安全的
- 如果该对象逃离方法的作用范围，如return，需要考虑线程安全

局部变量线程安全分析

public static void test1() {
  int i = 10; 
  i++; 
}

Untitled

如图：

Untitled

list是成员变量

public class TestThreadSafe {

    static final int THREAD_NUMBER = 2;
    static final int LOOP_NUMBER = 200;

    public static void main(String[] args) {
        ThreadUnsafe test = new ThreadUnsafe();
        for (int i = 0; i < THREAD_NUMBER; i++) { //创建2个线程
            new Thread(() -> {
                test.method1(LOOP_NUMBER); //循环200次
            }, "Thread" + (i+1)).start();
        }

    }

}

class ThreadUnsafe {

		// 成员变量list
    ArrayList<String> list = new ArrayList<>();

    public void method1(int loopNumber) {
        for (int i = 0; i < loopNumber; i++) {
          // { 临界区, 会产生竞态条件
            method2();
            method3();
          // } 临界区
        }
    }

    private void method2() {
        list.add("1"); //往集合添加一个元素
    }

    private void method3() {
        list.remove(0); //往集合删除一个元素
    }
}

Untitled

无论哪个线程中的 method2 引用的都是堆中同一个对象中的 list 成员变量
method3 与 method2 分析相同

Untitled

list 修改为局部变量

public class TestThreadSafe {

    static final int THREAD_NUMBER = 2;
    static final int LOOP_NUMBER = 200;

    public static void main(String[] args) {
        ThreadUnsafe test = new ThreadUnsafe();
        for (int i = 0; i < THREAD_NUMBER; i++) { //创建2个线程
            new Thread(() -> {
                test.method1(LOOP_NUMBER); //循环200次
            }, "Thread" + (i+1)).start();
        }

    }

}

class ThreadSafe {

    public final void method1(int loopNumber) {
        ArrayList<String> list = new ArrayList<>(); //局部变量list
        for (int i = 0; i < loopNumber; i++) {
            method2(list);
            method3(list);
        }
    }

    private void method2(ArrayList<String> list) {
        list.add("1");
    }

    private void method3(ArrayList<String> list) {
        list.remove(0);
    }
}

list 是局部变量，每个线程调用时会创建其不同的实例，没有共享
而 method2 的参数是从 method1 中传递过来的，与 method1 中引用同一个对象
method3 的参数分析与 method2 相同

Untitled

暴露list

情况1：有其它线程调用 method2 和 method3
- 其他线程调用method2，传过来的参数并不是method1的list，所以并不会产生线程安全问题
情况2：在情况1 的基础上，为 ThreadSafe 类添加子类，子类覆盖 method2 或 method3 方法，即
- 子类重写method3后，线程1或者线程2来到重写的method3这里，会与线程3使用同一共享资源，所以可能会产生线程安全问题

public class TestThreadSafe {

    static final int THREAD_NUMBER = 2;
    static final int LOOP_NUMBER = 200;

    public static void main(String[] args) {
        ThreadSafeSubClass test = new ThreadSafeSubClass();
        for (int i = 0; i < THREAD_NUMBER; i++) { //创建2个线程
            new Thread(() -> {
                test.method1(LOOP_NUMBER); //循环200次
            }, "Thread" + (i+1)).start();
        }

    }

}

class ThreadSafe {

    public void method1(int loopNumber) {
        ArrayList<String> list = new ArrayList<>(); //局部变量list
        for (int i = 0; i < loopNumber; i++) {
            method2(list);
            method3(list);
        }
    }

    public void method2(ArrayList<String> list) {
        list.add("1");
    }

    public void method3(ArrayList<String> list) {
        list.remove(0);
    }

}

class ThreadSafeSubClass extends ThreadSafe{

    @Override
    public void method3(ArrayList<String> list) {
        new Thread(() -> {
            list.remove(0);
        },"Thread3").start();
    }

}

Untitled

从这个例子可以看出 private 或 final 提供【安全】的意义所在，请体会开闭原则中的【闭】
可以给method1加上final防止被重写，给method2 和 method3加上private防止被子类重写

public class TestThreadSafe {

    static final int THREAD_NUMBER = 2;
    static final int LOOP_NUMBER = 200;

    public static void main(String[] args) {
        ThreadSafeSubClass test = new ThreadSafeSubClass();
        for (int i = 0; i < THREAD_NUMBER; i++) { //创建2个线程
            new Thread(() -> {
                test.method1(LOOP_NUMBER); //循环200次
            }, "Thread" + (i + 1)).start();
        }

    }

}

class ThreadSafe {

    public final void method1(int loopNumber) {
        ArrayList<String> list = new ArrayList<>(); //局部变量list
        for (int i = 0; i < loopNumber; i++) {
            method2(list);
            method3(list);
        }
    }

    private void method2(ArrayList<String> list) {
        list.add("1");
    }

    private void method3(ArrayList<String> list) {
        list.remove(0);
    }

}

class ThreadSafeSubClass extends ThreadSafe {

    public void method3(ArrayList<String> list) {
        new Thread(() -> {
            list.remove(0);
        }, "Thread3").start();
    }

}

加上private后，子类无法重写method3，子类的method3只是作为自己的一个成员方法。
启动后线程1和线程2都会访问本类的method2和method3，所以各自有自己的局部变量list，也就不会存在共享资源，因此不会有线程安全问题

常见线程安全类

String
Integer
StringBuffffer
Random
Vector
Hashtable
java.util.concurrent 包下的类

这里说它们是线程安全的是指，多个线程调用它们同一个实例的某个方法时，是线程安全的。也可以理解为

Hashtable table = new Hashtable();
new Thread(()->{
	table.put("key", "value1");
}).start();

new Thread(()->{
	table.put("key", "value2");
}).start();

它们的每个方法是原子的（因为直接加了synchronized在方法上）
但注意它们多个方法的组合不是原子的，见后面分析

Untitled

线程安全类方法的组合

Hashtable table = new Hashtable();
// 线程1，线程2
if( table.get("key") == null) {
	table.put("key", value);
}

Untitled

不可变类线程安全性

String、Integer 等都是不可变类，因为其内部的状态不可以改变，因此它们的方法都是线程安全的

有同学或许有疑问，String 有 replace，substring 等方法【可以】改变值啊，那么这些方法又是如何保证线程安全的呢？

Untitled

直接new了一个新的String对象，保证原对象的不可变

实例分析

public class MyServlet extends HttpServlet {

  // 是否安全？no	HashTable才是线程安全的
	Map<String,Object> map = new HashMap<>();
	// 是否安全？yes
	String S1 = "...";
	// 是否安全？yes
	final String S2 = "...";
	// 是否安全？no
	Date D1 = new Date();
	// 是否安全？no
  // D2的引用不会变，但是日期对象内的属性可以变
	final Date D2 = new Date();

	public void doGet(HttpServletRequest request,	HttpServletResponse response) {
  // 使用上述变量
 	}

}

public class MyServlet extends HttpServlet {

	// 是否安全？no
  private UserService userService = new UserServiceImpl();
	
  public void doGet(HttpServletRequest request, HttpServletResponse response) {
		userService.update(...);
  }

}

public class UserServiceImpl implements UserService {
	// 记录调用次数
	private int count = 0; //共享资源

  public void update() {
		// 临界区
		count++;
 	}

}

userService为成员变量，是共享资源，多个线程调用会出现线程安全问题。

@Aspect
@Component
public class MyAspect {
	// 是否安全？no
	private long start = 0L;
	
  @Before("execution(* *(..))")
	public void before() {
		start = System.nanoTime();
	}

  @After("execution(* *(..))")
	public void after() {
		long end = System.nanoTime();
		System.out.println("cost time:" + (end-start));
 	}

}

spring中的对象，没有额外说明的话，都是单例的。说明这个类的对象会被共享，对象的成员变量也会被共享。
解决方法，最好把前置、后置通知变为环绕通知，把成员变量做成局部变量。

public class MyServlet extends HttpServlet {

  // 是否安全 yes
	private UserService userService = new UserServiceImpl();
	public void doGet(HttpServletRequest request, HttpServletResponse response) {
		userService.update(...);
  }

}

public class UserServiceImpl implements UserService {
  // 是否安全 yes
  private UserDao userDao = new UserDaoImpl();

  public void update() {
    userDao.update();
  }
}

public class UserDaoImpl implements UserDao { 

  public void update() {
    String sql = "update user set password = ? where username = ?";
    // 是否安全 yes
    try (Connection conn = DriverManager.getConnection("","","")){
      // ...
    } catch (Exception e) {
      // ...
    }
  }

}

UserDaoImpl是线程安全的，没有成员变量，资源变量Connection也是作为方法内局部变量出现
UserServiceImpl是线程安全的，成员变量UserDao是线程安全的，内部状态也不会改变。
UserService是线程安全的，并不会改变它的内部状态。

public class MyServlet extends HttpServlet {
  // 是否安全
  private UserService userService = new UserServiceImpl();
  
  public void doGet(HttpServletRequest request, HttpServletResponse response) {
    userService.update(...);
  }
}

public class UserServiceImpl implements UserService {
  // 是否安全
  private UserDao userDao = new UserDaoImpl();

  public void update() {
    userDao.update();
  }
}

public class UserDaoImpl implements UserDao {
  // 是否安全 no
  private Connection conn = null;

  public void update() throws SQLException {
    String sql = "update user set password = ? where username = ?";
    conn = DriverManager.getConnection("","","");
    // ...
    conn.close();
  }
}

UserDaoImpl是线程不安全的，因为作为了成员变量，在多线程下，可能其中一个线程刚开启Connection，就被另一个给关了。
UserServiceImpl、UserService也变得线程不安全了。

public class MyServlet extends HttpServlet {
  // 是否安全
  private UserService userService = new UserServiceImpl();
  public void doGet(HttpServletRequest request, HttpServletResponse response) {
    userService.update(...);
  }
}

public class UserServiceImpl implements UserService { 
  public void update() {
    UserDao userDao = new UserDaoImpl(); //局部变量
    userDao.update();
  }
}

public class UserDaoImpl implements UserDao {
  // 是否安全
  private Connection = null;
  public void update() throws SQLException {
    String sql = "update user set password = ? where username = ?";
    conn = DriverManager.getConnection("","","");
    // ...
    conn.close();
  }
}

由于UserServiceImpl中每次都新创建userDao，且作为局部变量。而每次都创建新的，那么UserDaoImpl中的成员变量Connection也是新的。不会出现线程安全问题。
但不建议这样写，建议把Connection变成局部变量，这样子才是最正确的做法

public abstract class Test {

  public void bar() {
    // 是否安全 no，虽然是局部变量，但是它在foo()里面作为参数可能会暴露给其他线程
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    foo(sdf); 
  }

  public abstract foo(SimpleDateFormat sdf);

  public static void main(String[] args) {
    new Test().bar();
  }

}

其中 foo 的行为是不确定的，可能导致不安全的发生，被称之为外星方法

public void foo(SimpleDateFormat sdf) {
  String dateStr = "1999-10-11 00:00:00";
  for (int i = 0; i < 20; i++) {
    new Thread(() -> {
      try {
        sdf.parse(dateStr);
      } catch (ParseException e) {
        e.printStackTrace();
      }
    }).start();
  }
}

不想暴露给外面使用的，建议都加上final或者private，这样子可以增强类的安全性

习题

卖票练习

@Slf4j(topic = "c.ExerciseSell")
public class ExerciseSell {

    public static void main(String[] args) throws InterruptedException {
        // 模拟多人买票
        TicketWindow window = new TicketWindow(1000);

        // 所有线程的集合
        List<Thread> threadList = new ArrayList<>();
        // 卖出的票数统计，Vector是线程安全的
        List<Integer> amountList = new Vector<>();
        for (int i = 0; i < 2000; i++) {
            Thread thread = new Thread(() -> {
                // 买票
                int amount = window.sell(random(5));
                // 统计买票数
                amountList.add(amount);
            });
						//虽然ArrayList是线程不安全的，但是这个threadList只被主线程使用
						//不会被多个线程所共享，所以不用考虑线程安全问题
            threadList.add(thread); 
            thread.start();
        }

				// 等待所有线程执行完成
        for (Thread thread : threadList) {
            thread.join();
        }

        // 统计卖出的票数和剩余票数
        log.debug("余票：{}",window.getCount());
        log.debug("卖出的票数：{}", amountList.stream().mapToInt(i-> i).sum());
    }

    // Random 为线程安全
    static Random random = new Random();

    // 随机 1~5
    public static int random(int amount) {
        return random.nextInt(amount) + 1;
    }
}

// 售票窗口
class TicketWindow {
		// 余票数量
    private int count;

    public TicketWindow(int count) {
        this.count = count;
    }

    // 获取余票数量
    public int getCount() {
        return count;
    }

    // 售票
    public int sell(int amount) {
        if (this.count >= amount) {
            this.count -= amount;
            return amount;
        } else {
            return 0;
        }
    }
}

Untitled

窗口是共享变量，所有线程都会访问，进行买票操作

// 模拟多人买票
TicketWindow window = new TicketWindow(1000);

sell操作中，涉及到余票变量的读写操作，属于临界区

Untitled

TicketWindow中的余票数count是共享变量

Untitled

每一个线程买票时，都是先读count，再修改count，在多线程情况下，容易发生指令交错，线程不安全

解决方法

在sell方法上加synchronized，锁住TicketWindow的实例对象，也就是锁住count，就对count进行了保护，线程安全

// 售票
public synchronized int sell(int amount) {
    if (this.count >= amount) {
        this.count -= amount;
        return amount;
    } else {
        return 0;
    }
}

List<Integer> amountList = new ArrayList<>();

不行，原例中是new Vector，Vector是线程安全的，换成ArrayList那么对票的相加操作也会变得线程不安全。

Untitled

// 买票
int amount = window.sell(random(5));
// 统计买票数
amountList.add(amount);

其实仍然是线程安全的，因为两个方法虽然组合了，但是没有在组合的方法上加synchronized，在多线程下可能会发生指令交错。但是即使发生了也不影响，因为两个方法操作的并不是同一个共享变量。是线程安全的。

转账练习

@Slf4j(topic = "c.ExerciseTransfer")
public class ExerciseTransfer {

    public static void main(String[] args) throws InterruptedException {
        Account a = new Account(1000);
        Account b = new Account(1000);

        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                a.transfer(b, randomAmount()); //模拟a给b转账
            }
        }, "t1");

        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                b.transfer(a, randomAmount()); //模拟b给a转账
            }
        }, "t2");

        t1.start();
        t2.start();
        t1.join();
        t2.join();

        // 查看转账2000次后的总金额
        log.debug("total:{}", (a.getMoney() + b.getMoney()));
    }

    // Random 为线程安全
    static Random random = new Random();

    // 随机 1~100
    public static int randomAmount() {
        return random.nextInt(100) + 1;
    }
}

// 账户
class Account {

    private int money; //成员变量

    public Account(int money) {
        this.money = money;
    }

    public int getMoney() {
        return money;
    }

    public void setMoney(int money) {
        this.money = money;
    }

    // 转账
    public void transfer(Account target, int amount) {
        if (this.money >= amount) {
            this.setMoney(this.getMoney() - amount);
            target.setMoney(target.getMoney() + amount);
        }
    }

}

Untitled

有两个账户对象，每个账户对象里有自己的余额变量money作为共享变量。

Account a = new Account(1000);
Account b = new Account(1000);

Untitled

账户里有一个transfer方法，涉及到对共享变量money的读写操作，属于临界区

Untitled

然后分别开1000个线程去让a给b转账，开1000个线程让b给a转账，调用transfer方法。
即对共享变量money做读写的方法transfer，暴露在了多线程环境下。

Thread t1 = new Thread(() -> {
    for (int i = 0; i < 1000; i++) {
        a.transfer(b, randomAmount());
    }
}, "t1");

Thread t2 = new Thread(() -> {
    for (int i = 0; i < 1000; i++) {
        b.transfer(a, randomAmount());
    }
}, "t2");

在多线程下，发生指令交错，发生了线程安全问题，导致总金额为2054 > 2000

11:05:15.743 c.ExerciseTransfer [main] - total:2054

Process finished with exit code 0

解决方法

直接对transfer( )方法加synchronized？很遗憾，这样做并不能解决问题。

// 转账
public synchronized void transfer(Account target, int amount) {
        if (this.money >= amount) {
            this.setMoney(this.getMoney() - amount);
            target.setMoney(target.getMoney() + amount);
        }
}

结果，依然发生了线程安全问题

11:15:35.814 c.ExerciseTransfer [main] - total:423

Process finished with exit code 0

这是因为，transfer( )方法中，并不只是操作了自己的共享变量this.money，还操作了转账对象的共享变量target.money。
而synchronize直接加在成员方法上，等同于synchronized(this)，对自己的成员变量this.money加锁。
所以应该把两个共享变量都锁上，那么可以使用synchronized(Account.class)，对Account类加锁，那么Account类所有的实例对象都会被加上锁，即实现了锁住了两个对象的money

		// 转账
    public void transfer(Account target, int amount) {
        synchronized (Account.class) {
            if (this.money >= amount) {
                this.setMoney(this.getMoney() - amount);
                target.setMoney(target.getMoney() + amount);
            }
        }
    }

测试多次结果都正确

11:24:38.288 c.ExerciseTransfer [main] - total:2000

Process finished with exit code 0