java的同步方法和同步代码块，对象锁，类锁区别

java的同步方法和同步代码块，对象锁，类锁区别

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