线程8锁

题目：打印是one还是two

第一张情况：两个普通同步方法，打印结果是

One
Two

 1 package day1;
 2 
 3 public class TestThread8Monitor {
 4 
 5     public static void main(String[] args) {
 6         Number number = new Number();
 7         
 8         new Thread(new Runnable() {
 9             
10             @Override
11             public void run() {
12                 number.getOne();
13                 
14             }
15         }).start();
16         
17         new Thread(new Runnable() {
18             
19             @Override
20             public void run() {
21                 number.getTwo();
22             }
23         }).start();
24     }
25 
26 }
27 
28 class Number {
29     
30     public synchronized void getOne() {
31         System.out.println("One");
32     }
33     
34     public synchronized void getTwo() {
35         System.out.println("Two");
36     }
37 }

第二种情况：在getOne方法中新增一个Thread.sleep()调用，打印结果

One
Two

 1 package day1;
 2 
 3 public class TestThread8Monitor {
 4 
 5     public static void main(String[] args) {
 6         Number number = new Number();
 7         
 8         new Thread(new Runnable() {
 9             
10             @Override
11             public void run() {
12                 number.getOne();
13                 
14             }
15         }).start();
16         
17         new Thread(new Runnable() {
18             
19             @Override
20             public void run() {
21                 number.getTwo();
22             }
23         }).start();
24     }
25 
26 }
27 
28 class Number {
29     
30     public synchronized void getOne() {
31         
32         try {
33             Thread.sleep(3000);
34         } catch (Exception e) {
35             // TODO: handle exception
36         }
37         
38         System.out.println("One");
39     }
40     
41     public synchronized void getTwo() {
42         System.out.println("Two");
43     }
44 }

第三种情况：在Number类中新增一个普通方法，打印结果

Three
One
Two

/**
 * 
 */
package day1;

public class TestThread8Monitor {

    public static void main(String[] args) {
        Number number = new Number();
        
        new Thread(new Runnable() {
            
            @Override
            public void run() {
                number.getOne();
                
            }
        }).start();
        
        new Thread(new Runnable() {
            
            @Override
            public void run() {
                number.getTwo();
            }
        }).start();
        
        new Thread(new Runnable() {
            
            @Override
            public void run() {
                number.getThree();
            }
        }).start();
    }

}

class Number {
    
    public synchronized void getOne() {
        
        try {
            Thread.sleep(3000);
        } catch (Exception e) {
            // TODO: handle exception
        }
        
        System.out.println("One");
    }
    
    public synchronized void getTwo() {
        System.out.println("Two");
    }
    
    public void getThree() {
        System.out.println("Three");
    }
}

第四种情况：两个普通同步方法，两个Number对象，打印结果

Two
One

 1 /**
 2  * 
 3  */
 4 package day1;
 5 
 6 public class TestThread8Monitor {
 7 
 8     public static void main(String[] args) {
 9         Number number = new Number();
10         Number number2 = new Number();
11         
12         new Thread(new Runnable() {
13             
14             @Override
15             public void run() {
16                 number.getOne();
17                 
18             }
19         }).start();
20         
21         new Thread(new Runnable() {
22             
23             @Override
24             public void run() {
25                 number2.getTwo();
26             }
27         }).start();
28         
29         
30     }
31 
32 }
33 
34 class Number {
35     
36     public synchronized void getOne() {
37         
38         try {
39             Thread.sleep(3000);
40         } catch (Exception e) {
41             // TODO: handle exception
42         }
43         
44         System.out.println("One");
45     }
46     
47     public synchronized void getTwo() {
48         System.out.println("Two");
49     }
50     
51     public void getThree() {
52         System.out.println("Three");
53     }
54 }

第五种情况：修改getOne()为静态同步方法，打印结果

Two
One

 1 /**
 2  * 
 3  */
 4 package day1;
 5 
 6 public class TestThread8Monitor {
 7 
 8     public static void main(String[] args) {
 9         Number number = new Number();
10         
11         new Thread(new Runnable() {
12             
13             @Override
14             public void run() {
15                 number.getOne();
16                 
17             }
18         }).start();
19         
20         new Thread(new Runnable() {
21             
22             @Override
23             public void run() {
24                 number.getTwo();
25             }
26         }).start();
27         
28         
29     }
30 
31 }
32 
33 class Number {
34     
35     public static synchronized void getOne() {
36         
37         try {
38             Thread.sleep(3000);
39         } catch (Exception e) {
40             // TODO: handle exception
41         }
42         
43         System.out.println("One");
44     }
45     
46     public synchronized void getTwo() {
47         System.out.println("Two");
48     }
49     
50     public void getThree() {
51         System.out.println("Three");
52     }
53 }

第六种情况：修改两个方法均为静态同步方法，一个Number对象，打印结果

One
Two

 1 /**
 2  * 
 3  */
 4 package day1;
 5 
 6 public class TestThread8Monitor {
 7 
 8     public static void main(String[] args) {
 9         Number number = new Number();
10         
11         new Thread(new Runnable() {
12             
13             @Override
14             public void run() {
15                 number.getOne();
16                 
17             }
18         }).start();
19         
20         new Thread(new Runnable() {
21             
22             @Override
23             public void run() {
24                 number.getTwo();
25             }
26         }).start();
27         
28         
29     }
30 
31 }
32 
33 class Number {
34     
35     public static synchronized void getOne() {
36         
37         try {
38             Thread.sleep(3000);
39         } catch (Exception e) {
40             // TODO: handle exception
41         }
42         
43         System.out.println("One");
44     }
45     
46     public static synchronized void getTwo() {
47         System.out.println("Two");
48     }
49     
50     public void getThree() {
51         System.out.println("Three");
52     }
53 }

第七章情况：一种是静态同步方法，一个非静态同步方法，两个Number对象，打印结果

Two
One

 1 /**
 2  * 
 3  */
 4 package day1;
 5 
 6 public class TestThread8Monitor {
 7 
 8     public static void main(String[] args) {
 9         Number number = new Number();
10         Number number2 = new Number();
11         
12         new Thread(new Runnable() {
13             
14             @Override
15             public void run() {
16                 number.getOne();
17                 
18             }
19         }).start();
20         
21         new Thread(new Runnable() {
22             
23             @Override
24             public void run() {
25                 number2.getTwo();
26             }
27         }).start();
28         
29         
30     }
31 
32 }
33 
34 class Number {
35     
36     public static synchronized void getOne() {
37         
38         try {
39             Thread.sleep(3000);
40         } catch (Exception e) {
41             // TODO: handle exception
42         }
43         
44         System.out.println("One");
45     }
46     
47     public synchronized void getTwo() {
48         System.out.println("Two");
49     }
50     
51     public void getThree() {
52         System.out.println("Three");
53     }
54 }

第第八种情况：两个静态同步方法，两个Number对象，打印

One
Two

 1 /**
 2  * 
 3  */
 4 package day1;
 5 
 6 public class TestThread8Monitor {
 7 
 8     public static void main(String[] args) {
 9         Number number = new Number();
10         Number number2 = new Number();
11         
12         new Thread(new Runnable() {
13             
14             @Override
15             public void run() {
16                 number.getOne();
17                 
18             }
19         }).start();
20         
21         new Thread(new Runnable() {
22             
23             @Override
24             public void run() {
25                 number2.getTwo();
26             }
27         }).start();
28         
29         
30     }
31 
32 }
33 
34 class Number {
35     
36     public static synchronized void getOne() {
37         
38         try {
39             Thread.sleep(3000);
40         } catch (Exception e) {
41             // TODO: handle exception
42         }
43         
44         System.out.println("One");
45     }
46     
47     public static synchronized void getTwo() {
48         System.out.println("Two");
49     }
50     
51     public void getThree() {
52         System.out.println("Three");
53     }
54 }

相关阅读:
压缩感知理论模型
 欢迎使用CSDN-markdown编辑器
 CEF3 概览及一般使用方法
 如何利用CEF3创建一个简单的应用程序 (Windows Platform)
递归(浅解)
day22 ftp传输作业未完成
 day21(套接字初应用)
Multiprocess.Process(源码)
day20 网络编程(初识)
day19(异常补遗)
原文地址：https://www.cnblogs.com/wylwyl/p/10522114.html