1
Hashtable table = new Hashtable();
2
// 线程1，线程2 执行下面方法
3
if( table.get("key") == null) {
4
    table.put("key", value);
5
}

1
public String substring(int beginIndex) {
2
    if (beginIndex < 0) {
3
        throw new StringIndexOutOfBoundsException(beginIndex);
4
    } else {
5
        int subLen = this.length() - beginIndex;
6
        if (subLen < 0) {
7
            throw new StringIndexOutOfBoundsException(subLen);
8
        } else if (beginIndex == 0) {
9
            return this;
10
        } else {
11
            // 核心代码 内部调用了 System.arrayCopy() 来复制字符数组
12
            return this.isLatin1() ? StringLatin1.newString(this.value, beginIndex, subLen) : StringUTF16.newString(this.value, beginIndex, subLen);
13
        }
14
    }
15
}
16

17
// 由此可见，这些方法底层都是新建了一个 String 对象，并把旧对象上的数据复制到新对象上
18
public static String newString(byte[] val, int index, int len) {
19
    return new String(Arrays.copyOfRange(val, index, index + len), (byte)0);
20
}

1
public class MyServlet extends HttpServlet {
2
    // 是否安全？  HashMap 是线程不安全的
3
    Map<String,Object> map = new HashMap<>();
4
    // 是否安全？  安全
5
    String S1 = "...";
6
    // 是否安全？  安全
7
    final String S2 = "...";
8
    // 是否安全？  不安全，常见线程安全类中没有
9
    Date D1 = new Date();
10
    // 是否安全？  不安全，final 只能保证 D2 这个成员变量的引用值不能变。
11
    //             但是这个日期里面的属性可以发生变化
12
    final Date D2 = new Date();
13

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

1
public class MyServlet extends HttpServlet {
2
    // 是否安全？  不安全，UserService 是成员变量，被共享使用
3
    private UserService userService = new UserServiceImpl();
4

5
    public void doGet(HttpServletRequest request, HttpServletResponse response) {
6
        userService.update(...);
7
    }
8
}
9

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

14
    public void update() {
15
        // 临界区
16
        count++;
17
    }
18
}

1
@Aspect
2
@Component
3
public class MyAspect {
4
    // 是否安全？ 不安全
5
    // Spring 中的 bean 没有特殊说明的话，默认情况下都是单例的
6
    // 由于 MyAspect 是单例的，是被共享的；那 start 这个成员变量也是被共享的
7
    private long start = 0L;
8

9
    @Before("execution(* *(..))")
10
    public void before() {
11
        start = System.nanoTime();
12
    }
13

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

1
public class MyServlet extends HttpServlet {
2
    // 是否安全  虽然 UserService 中有一个 UserDao 的成员变量，但是没有其他的地方可以修改它。
3
    //       所以这个成员变量 UserDao 是不可变的，所以是安全的
4
    private UserService userService = new UserServiceImpl();
5

6
    public void doGet(HttpServletRequest request, HttpServletResponse response) {
7
        userService.update(...);
8
    }
9
}
10

11
public class UserServiceImpl implements UserService {
12
    // 是否安全  虽然 UserDao 是成员变量，也会被共享。但内部没有可以更改的属性。所以是安全的
13
    private UserDao userDao = new UserDaoImpl();
14

15
    public void update() {
16
        userDao.update();
17
    }
18
}
19

20
public class UserDaoImpl implements UserDao {
21
    public void update() {
22
        String sql = "update user set password = ? where username = ?";
23
        // 是否安全  因为没有成员变量，Connection 是局部变量。所以是线程安全的
24
        try (Connection conn = DriverManager.getConnection("","","")){
25
            // ...
26
        } catch (Exception e) {
27
            // ...
28
        }
29
    }
30
}

1
public class MyServlet extends HttpServlet {
2
    // 是否安全  安全。思路同上
3
    private UserService userService = new UserServiceImpl();
4

5
    public void doGet(HttpServletRequest request, HttpServletResponse response) {
6
        userService.update(...);
7
    }
8
}
9

10
public class UserServiceImpl implements UserService {
11
    // 是否安全  安全。思路同上
12
    private UserDao userDao = new UserDaoImpl();
13

14
    public void update() {
15
        userDao.update();
16
    }
17
}
18

19
public class UserDaoImpl implements UserDao {
20
    // 是否安全  由于 UserDaoImpl 是被多个线程所共享的，所以 Connection 是被共享的成员变量
21
    //        所以是线程不安全的
22
    private Connection conn = null;
23
    public void update() throws SQLException {
24
        String sql = "update user set password = ? where username = ?";
25
        conn = DriverManager.getConnection("","","");
26
        // ...
27
        conn.close();
28
    }
29
}

1
public class MyServlet extends HttpServlet {
2
    // 是否安全  安全。思路同上
3
    private UserService userService = new UserServiceImpl();
4

5
    public void doGet(HttpServletRequest request, HttpServletResponse response) {
6
        userService.update(...);
7
    }
8
}
9

10
public class UserServiceImpl implements UserService {
11
    public void update() {
12
        UserDao userDao = new UserDaoImpl();
13
        userDao.update();
14
    }
15
}
16

17
public class UserDaoImpl implements UserDao {
18
    // 是否安全  由于 前面的 service 中每次都创建了一个新的 UserDao 对象，所以多个线程操作的
19
    //          不是同一个对象，是线程安全的
20
    private Connection = null;
21
    public void update() throws SQLException {
22
        String sql = "update user set password = ? where username = ?";
23
        conn = DriverManager.getConnection("","","");
24
        // ...
25
        conn.close();
26
    }
27
}

1
public abstract class Test {
2

3
    public void bar() {
4
        // 是否安全  由于是抽象类，局部变量 sdf 可能会传递给抽象方法 foo。
5
        //        可能子类会进行不恰当的实现。所以是线程不安全的
6
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
7
        foo(sdf);
8
    }
9

10
    public abstract foo(SimpleDateFormat sdf);
11

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

16
}

1
public void foo(SimpleDateFormat sdf) {
2
    String dateStr = "1999-10-11 00:00:00";
3
    for (int i = 0; i < 20; i++) {
4
        new Thread(() -> {
5
            try {
6
                sdf.parse(dateStr);
7
            } catch (ParseException e) {
8
                e.printStackTrace();
9
            }
10
        }).start();
11
    }
12
}

1
@Slf4j(topic = "c.ExerciseSell")
2
public class ExerciseSell {
3
    public static void main(String[] args) throws InterruptedException {
4
        // TODO 模拟多线程场景下买票操作
5
        TicketWindow ticket = new TicketWindow(1000);  // 创建一个售票窗口，有 1000 张票
6

7
        // 所有线程集合
8
        List<Thread> threadList = new ArrayList<>();
9
        // 统计卖出的票数
10
        List<Integer> amountList = new Vector<>();  // Vector 是线程安全的实现
11
        for (int i = 0; i < 4000; i++) {
12
            Thread thread = new Thread(() -> {
13
                // 买票
14
                int amount = ticket.sell(randomAmount());
15
                amountList.add(amount);
16
            });
17

18
            // threadList只在主线程中被创建和使用,是非共享数据,没有其他线程修改它。
19
            // 所以是线程安全的。可以使用 ArrayList 来创建
20
            threadList.add(thread);
21
            thread.start();
22
        }
23

24
        // 主线程需要等待所有线程运行结束，再往下执行
25
        for (Thread thread : threadList) {
26
            thread.join();
27
        }
28

29
        // 统计卖出的票数和剩余的票数
30
        log.debug("余票数量为：{}", ticket.getCount());
31
        log.debug("卖出的票数为：{}", amountList.stream().mapToInt(Integer::intValue).sum());
32
    }
33

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

37
    /**
38
     * 随机产生 1~5
39
     *
40
     * @return 产生的值
41
     */
42
    public static int randomAmount() {
43
        return random.nextInt(5) + 1;
44
    }
45
}
46

47
/**
48
 * 售票窗口
49
 */
50
class TicketWindow {
51
    private int count;
52

53
    public TicketWindow(int count) {
54
        this.count = count;
55
    }
56

57
    // 获取余票数量
58
    public int getCount() {
59
        return count;
60
    }
61

62
    // 售票
63
    public int sell(int amount) {
64
        if (this.count >= amount) {
65
            this.count -= amount;
66
            return amount;
67
        } else {
68
            return 0;
69
        }
70
    }
71
}