剑指JUC原理-4.共享资源和线程安全性（上）:https://developer.aliyun.com/article/1413590

情况5：

class Number{
 public static synchronized void a() {
 sleep(1);
 log.debug("1");
 }
 public synchronized void b() {
 log.debug("2");
 }
}
public static void main(String[] args) {
 Number n1 = new Number();
 new Thread(()->{ n1.a(); }).start();
 new Thread(()->{ n1.b(); }).start();
}

2 1s 后 1 这个情况其实和前面说的一样，实际上是关于锁对象的概念，就是如果给静态方法加锁，实际上的锁对象是类本身，而不是实例对象，而给普通方法加锁，锁对象是实例对象，所以自然是这个结果

情况6：

class Number{
 public static synchronized void a() {
 sleep(1);
 log.debug("1");
 }
 public static synchronized void b() {
 log.debug("2");
 }
}
public static void main(String[] args) {
 Number n1 = new Number();
 new Thread(()->{ n1.a(); }).start();
 new Thread(()->{ n1.b(); }).start();
}

1s 后12，或 2 1s后 1 实际上和情况1类似，只不过锁对象由实例对象替换成了类对象

情况7：

class Number{
 public static synchronized void a() {
 sleep(1);
 log.debug("1");
 }
 public synchronized void b() {
 log.debug("2");
 }
}
public static void main(String[] args) {
 Number n1 = new Number();
 Number n2 = new Number();
 new Thread(()->{ n1.a(); }).start();
 new Thread(()->{ n2.b(); }).start();
}

2 1s 后 1 这个情况也非常好分析，锁对象不同

情况8：

class Number{
 public static synchronized void a() {
 sleep(1);
 log.debug("1");
 }
 public static synchronized void b() {
 log.debug("2");
 }
}
public static void main(String[] args) {
 Number n1 = new Number();
 Number n2 = new Number();
 new Thread(()->{ n1.a(); }).start();
 new Thread(()->{ n2.b(); }).start();
}

1s 后12，或 2 1s后 1 该情况和前面情况重复，不在介绍

变量的线程安全分析

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

如果它们没有共享，则线程安全

如果它们被共享了，根据它们的状态是否能够改变，又分两种情况

如果只有读操作，则线程安全
如果有读写操作，则这段代码是临界区，需要考虑线程安全

局部变量是否线程安全？

局部变量是线程安全的

但局部变量引用的对象则未必

如果该对象没有逃离方法的作用访问，它是线程安全的
如果该对象逃离方法的作用范围，需要考虑线程安全

局部变量线程安全分析

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

每个线程调用 test1() 方法时局部变量 i，会在每个线程的栈帧内存中被创建多份，因此不存在共享

局部变量的引用稍有不同

先看一个成员变量的例子

class ThreadUnsafe {
 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);
 }
}

执行

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++) {
 new Thread(() -> {
 test.method1(LOOP_NUMBER);
 }, "Thread" + i).start();
 }
}

其中一种情况是，如果线程2 还未 add，线程1 remove 就会报错：

Exception in thread "Thread1" java.lang.IndexOutOfBoundsException: Index: 0, Size: 0 
 at java.util.ArrayList.rangeCheck(ArrayList.java:657) 
 at java.util.ArrayList.remove(ArrayList.java:496) 
 at cn.itcast.n6.ThreadUnsafe.method3(TestThreadSafe.java:35) 
 at cn.itcast.n6.ThreadUnsafe.method1(TestThreadSafe.java:26) 
 at cn.itcast.n6.TestThreadSafe.lambda$main$0(TestThreadSafe.java:14) 
 at java.lang.Thread.run(Thread.java:748)

分析：

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

将 list 修改为局部变量

class ThreadSafe {
 public final void method1(int loopNumber) {
 ArrayList<String> list = new ArrayList<>();
 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 相同

方法访问修饰符带来的思考，如果把 method2 和 method3 的方法修改为 public 会不会代理线程安全问题？

情况1：有其它线程调用 method2 和 method3，有可能被其他线程调用到，此时的list不一定是局部变量了

情况2：在情况1 的基础上，为 ThreadSafe 类添加子类，子类覆盖 method2 或 method3 方法，即

class ThreadSafe {
 public final void method1(int loopNumber) {
 ArrayList<String> list = new ArrayList<>();
 for (int i = 0; i < loopNumber; i++) {
 method2(list);
 method3(list);
 }
 }
 private 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);
 }).start();
 }
}

从这个例子可以看出 private 或 final 提供【安全】的意义所在，请体会开闭原则中的【闭】

常见的线程安全类

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

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

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

它们的每个方法是原子的

但注意它们多个方法的组合不是原子的

线程安全类方法的组合

分析下面代码是否线程安全？

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

不可变类线程安全性

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

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

进入replace源码查看：

public String replace(char oldChar, char newChar) {
        if (oldChar != newChar) {
            int len = value.length;
            int i = -1;
            char[] val = value; /* avoid getfield opcode */
            while (++i < len) {
                if (val[i] == oldChar) {
                    break;
                }
            }
            if (i < len) {
                char buf[] = new char[len];
                for (int j = 0; j < i; j++) {
                    buf[j] = val[j];
                }
                while (i < len) {
                    char c = val[i];
                    buf[i] = (c == oldChar) ? newChar : c;
                    i++;
                }
                return new String(buf, true);
            }
        }
        return this;
    }

其实可以看到最终的返回是 return 了一个新的String对象，并不是改变值。

以一个例子来举例：

public class Immutable{
 private int value = 0;
 public Immutable(int value){
 this.value = value;
 }
 public int getValue(){
 return this.value;
 }
}

如果想增加一个增加的方法呢？

public class Immutable{
 private int value = 0;
 public Immutable(int value){
 this.value = value;
 }
 public int getValue(){
 return this.value;
 }
 public Immutable add(int v){
 return new Immutable(this.value + v);
 } 
}

实例分析

例1：

// 是否安全？
 Map<String,Object> map = new HashMap<>();
 // 是否安全？
 String S1 = "...";
 // 是否安全？
 final String S2 = "...";
 // 是否安全？
 Date D1 = new Date();
 // 是否安全？
 final Date D2 = new Date();

其中map不是线程安全的，map的线程安全由其他方式实现

s1 和 s2都是线程安全的

D1 不是线程安全的

D2 虽然加了final，但是日期是可变类，里面的值是可以改变的

例2：

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 int count = 0;
 public void update() {
 // ...
 count++;
 }
}

并不是线程安全的，原因是 impl中有临界区资源没被控制

例3：

@Aspect
@Component
public class MyAspect {
 // 是否安全？
 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是单例，所以临界区资源要被共享，如果想保证线程安全，那么可以使用环绕通知来实现，此时 start 和 after都是局部变量，那么此时就不存在线程安全问题了。

例4：

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 { 
 public void update() {
 String sql = "update user set password = ? where username = ?";
 // 是否安全
 try (Connection conn = DriverManager.getConnection("","","")){
 // ...
 } catch (Exception e) {
 // ...
 }
 }
}

本质上是线程安全的，没有成员变量，Conn 属于一个方法内部的局部变量，每个线程得到的都是一个新的。

例5：

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();
 }
}

其中虽然UserDao 线程不安全，但是 UserServiceImpl它在局部变量中，不存在线程不安全

例7：

public void bar() {
 // 是否安全
 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();
 }
}

其实在这里面也就可以理解了，String不设置为null，其子类就有可能覆盖其中的一些行为，导致线程不安全性。

卖票问题

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;
 }
 }
}
public static void main(String[] args) {
 TicketWindow ticketWindow = new TicketWindow(2000);
 List<Thread> list = new ArrayList<>();
 // 用来存储买出去多少张票
 List<Integer> sellCount = new Vector<>();
 for (int i = 0; i < 2000; i++) {
 Thread t = new Thread(() -> {
 // 分析这里的竞态条件
 int count = ticketWindow.sell(randomAmount());
 sellCount.add(count);
 });
 list.add(t);
 t.start();
 }
 list.forEach((t) -> {
 try {
 t.join();
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
 });
 // 买出去的票求和
 log.debug("selled count:{}",sellCount.stream().mapToInt(c -> c).sum());
 // 剩余票数
 log.debug("remainder count:{}", ticketWindow.getCount());
 }
 // Random 为线程安全
 static Random random = new Random();
 // 随机 1~5
 public static int randomAmount() {
 return random.nextInt(5) + 1;
 }

这段代码中是存在线程安全的问题的，但是线程安全的问题不好复现，可以加上sleep来方便复现问题。

通过分析代码，发现是sell方法里面的临界资源出现了线程不安全的问题

解决方法就是再方法上加入 synchronized。

但是其实代码中还是存在很多细节的：

比如说，再线程中有一个sellCount.add的操作，这个操作其实是多线程操作，每一个线程都需要执行，而普通的list集合是线程不安全的，所以代码中使用的是 Vector，具体再java中源码如下：

ArrayList
public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }
Vector
public synchronized boolean add(E e) {
        modCount++;
        ensureCapacityHelper(elementCount + 1);
        elementData[elementCount++] = e;
        return true;
    }

而后面还有一个list.add 这个没有用线程安全的集合实现，原因就是因为它是执行在主线程中，本身就不存在线程安全的问题。

转账问题

测试下面代码是否存在线程安全问题，并尝试改正

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

其实根据卖票问题，代码中也是存在一个线程不安全问题的。但是不能像卖票问题一样，加一个锁就可以了，仔细分析一下发现 transfer中存在两个共享变量，money 和 target，如果对方法加synchronized ，实际上只对money这个共享变量上锁了，而 target并没有，解决办法其实就是对他们两个的父类上锁，也就是锁对象是Account.class。

剑指JUC原理-4.共享资源和线程安全性（下）

情况5：

情况6：

情况7：

情况8：

变量的线程安全分析

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

局部变量是否线程安全？

局部变量线程安全分析

常见的线程安全类

实例分析

例1：

例2：

例3：

例4：

例5：

例7：

卖票问题

转账问题

热门文章

最新文章

相关电子书

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

剑指JUC原理-4.共享资源和线程安全性（下）

情况5：

情况6：

情况7：

情况8：

变量的线程安全分析

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

局部变量是否线程安全？

局部变量线程安全分析

常见的线程安全类

实例分析

例1：

例2：

例3：

例4：

例5：

例7：

卖票问题

转账问题

热门文章

最新文章

相关电子书