1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

/**

 * @author admin

 * @date 2018/1/12 9:48

 * 作用在同一个实例对象上讨论

 * synchronized同步方法的测试

 * 两个线程，一个线程调用synchronized修饰方法，另一个线程可以调用非synchronized修饰的方法，互不影响

 */

public class SynchronizedTest {

    public synchronized void methodA() {

        try {

            for (int i = 0; i < 5; i++) {

                System.out.println("methodA-" + i);

                Thread.sleep(1000);

            }

        } catch (InterruptedException e) {

            e.printStackTrace();

        }

    }

    public void methodB() {

        try {

            for (int i = 0; i < 5; i++) {

                System.out.println("methodB-" + i );

                Thread.sleep(1000);

            }

        } catch (InterruptedException e) {

            e.printStackTrace();

        }

    }

    public static void main(String[] args) {

        SynchronizedTest test = new SynchronizedTest();

        Thread thread1 = new Thread(new Runnable() {

            @Override

            public void run() {

                test.methodA();

            }

        });

        thread1.start();

        Thread thread2 = new Thread(new Runnable() {

            @Override

            public void run() {

                test.methodB();

            }

        });

        thread2.start();

    }

}

运行结果：

methodA-0

methodB-0

methodA-1

methodB-1

methodB-2

methodA-2

methodA-3

methodB-3

methodA-4

methodB-4

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

/**

 * @author admin

 * @date 2018/1/12 10:16

 * 作用在同一个实例对象上讨论

 * Sychronized代码块的测试

 * 两个线程，一个线程执行synchronized代码块，另一个线程执行非synchronized代码块

 */

public class SychronizedTest2 {

    public void methodA() {

        synchronized (this) {

            try {

                for (int i = 0; i < 5; i++) {

                    System.out.println("methodA-" + i);

                    Thread.sleep(1000);

                }

            } catch (InterruptedException e) {

                e.printStackTrace();

            }

        }

    }

    public void methodB() {

        try {

            for (int i = 0; i < 5; i++) {

                System.out.println("methodB-" + i);

                Thread.sleep(1000);

            }

        } catch (InterruptedException e) {

            e.printStackTrace();

        }

    }

    public static void main(String[] args) {

        SychronizedTest2 test2 = new SychronizedTest2();

        Thread thread1 = new Thread(new Runnable() {

            @Override

            public void run() {

               test2.methodA();

            }

        });

        thread1.start();

        Thread thread2 = new Thread(new Runnable() {

            @Override

            public void run() {

                test2.methodB();

            }

        });

        thread2.start();

    }

}

运行结果：

methodA-0

methodB-0

methodA-1

methodB-1

methodA-2

methodB-2

methodB-3

methodA-3

methodA-4

methodB-4

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

/**

 * @author admin

 * @date 2018/1/12 10:33

 * 作用在同一个实例对象上讨论

 * Synchronized同步方法和同步代码块

 * 1、synchronized和synchronized（this）二者没区别，都作用在this对象锁上面，所以会同步

 * 2、synchronized（obj），这个是作用在obj对象锁上面，和this对象锁不同，所以不会同步

 */

public class SynchronizedTest3 {

    public synchronized void methodA() {

        try {

            for (int i = 0; i < 5; i++) {

                System.out.println("methodA-" + i);

                Thread.sleep(1000);

            }

        } catch (InterruptedException e) {

            e.printStackTrace();

        }

    }

    public void methodB() {

        synchronized (this) {

            try {

                for (int i = 0; i < 5; i++) {

                    System.out.println("methodB-" + i);

                    Thread.sleep(1000);

                }

            } catch (InterruptedException e) {

                e.printStackTrace();

            }

        }

    }

    public void methodC() {

        Object obj = new Object();

        synchronized (obj) {

            try {

                for (int i = 0; i < 5; i++) {

                    System.out.println("methodC-" + i);

                    Thread.sleep(1000);

                }

            } catch (InterruptedException e) {

                e.printStackTrace();

            }

        }

    }

    public static void main(String[] args) {

        SynchronizedTest3 test3 = new SynchronizedTest3();

        Thread thread1 = new Thread(new Runnable() {

            @Override

            public void run() {

                test3.methodA();

            }

        });

        thread1.start();

        Thread thread2 = new Thread(new Runnable() {

            @Override

            public void run() {

                test3.methodB();

            }

        });

        thread2.start();

        Thread thread3 = new Thread(new Runnable() {

            @Override

            public void run() {

                test3.methodC();

            }

        });

        thread3.start();

    }

}

运行结果：

methodA-0

methodC-0

methodA-1

methodC-1

methodA-2

methodC-2

methodA-3

methodC-3

methodA-4

methodC-4

methodB-0

methodB-1

methodB-2

methodB-3

methodB-4

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

/**

 * @author admin

 * @date 2018/1/12 10:48

 * 作用在同一个类上讨论，每一个类只有一个类锁

 * synchronized类锁

 * static synchronized 和 synchronized（SynchronizedTest4.class）,都是作用在同一个类锁上，所以会同步

 */

public class SynchronizedTest4 {

    public synchronized static void methodA() {

        try {

            for (int i = 0; i < 5; i++) {

                System.out.println("methodA-" + i);

                Thread.sleep(1000);

            }

        } catch (InterruptedException e) {

            e.printStackTrace();

        }

    }

    public void methodB() {

        synchronized (SynchronizedTest4.class) {

            try {

                for (int i = 0; i < 5; i++) {

                    System.out.println("methodB-" + i);

                    Thread.sleep(1000);

                }

            } catch (InterruptedException e) {

                e.printStackTrace();

            }

        }

    }

    public static void main(String[] args) {

        SynchronizedTest4 test4 = new SynchronizedTest4();

        Thread thread1 = new Thread(new Runnable() {

            @Override

            public void run() {

                test4.methodA();

            }

        });

        thread1.start();

        Thread thread2 = new Thread(new Runnable() {

            @Override

            public void run() {

                test4.methodB();

            }

        });

        thread2.start();

    }

}

运行结果：

methodA-0

methodA-1

methodA-2

methodA-3

methodA-4

methodB-0

methodB-1

methodB-2

methodB-3

methodB-4

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

/**

 * @author admin

 * @date 2018/1/12 11:03

 * synchronized的对象锁和static synchronized的类锁，是两个不同的锁，所以不会同步

 * 两个线程，一个调用对象锁，一个调用类锁

 */

public class SynchronizedTest5 {

    public synchronized  void methodA() {

        try {

            for (int i = 0; i < 5; i++) {

                System.out.println("methodA-" + i);

                Thread.sleep(1000);

            }

        } catch (InterruptedException e) {

            e.printStackTrace();

        }

    }

    public synchronized static void methodB() {

        try {

            for (int i = 0; i < 5; i++) {

                System.out.println("methodB-" + i);

                Thread.sleep(1000);

            }

        } catch (InterruptedException e) {

            e.printStackTrace();

        }

    }

    public static void main(String[] args) {

        SynchronizedTest5 test5 = new SynchronizedTest5();

        Thread thread1 = new Thread(new Runnable() {

            @Override

            public void run() {

                test5.methodA();

            }

        });

        thread1.start();

        Thread thread2 = new Thread(new Runnable() {

            @Override

            public void run() {

                test5.methodB();

            }

        });

        thread2.start();

    }

}

运行结果：

methodA-0

methodB-0

methodA-1

methodB-1

methodB-2

methodA-2

methodB-3

methodA-3

methodB-4

methodA-4