互联网并发编程（4）--synchronized的细节问题

- 日理万妓 2022-05-28 06:09 149阅读 0赞

内容：  
锁重入的问题  
异常释放锁的问题  
synchronized代码块

--------------------

## 锁重入的问题 ##

关键字synchronized拥有锁重入的功能，也就是说在使用synchronized时候，当一个线程得到一个对象的锁，再次请求该对象的时候可以再次得到该对象的锁。

案例一：

package com.wuk.thread;
    
    public class ThreadTest07 implements Runnable{ 
    
        @Override
        public void run() {
    
            method1();
        }
    
        public synchronized void method1(){
    
            System.out.println("method1...");
            method2();
        } 
    
        public synchronized  void method2(){
    
            System.out.println("method2...");
            method3();
        } 
    
        public synchronized  void method3(){
    
            System.out.println("method3...");
    
        } 
    
        public static void main(String[] args) {
    
            ThreadTest07 threadTest07=new ThreadTest07();
    
            new Thread(threadTest07).start();
    
        }
    
    }

结果：

method1...
    method2...
    method3...

案例二：  
Main类

package com.wuk.thread;
    public  class Main {
    
        public int i=10;
        public synchronized void  operationSup(){
    
            i--;
            System.out.println("Main print i="+i);
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

Sub类

package com.wuk.thread;
    
    public class Sub extends Main{ 
    
        public synchronized void operationSub(){
    
            while(i>0){
    
                i--;
                System.out.println("Sub print i="+i);
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                this.operationSup();    
            }
        }
    }

package com.wuk.thread;
    public class ThreadTest05 { 
    
        public static void main(String[] args) {
            Thread t1=new Thread(new Runnable() {
    
                @Override
                public void run() {     
                    Sub sub=new Sub();
                    sub.operationSub();
                }
            });
            t1.start();
        }
    
    }

结果：

Sub print i=9
    Main print i=8
    Sub print i=7
    Main print i=6
    Sub print i=5
    Main print i=4
    Sub print i=3
    Main print i=2
    Sub print i=1
    Main print i=0

--------------------

出现异常，锁自动释放  
对于web应用程序，异常释放锁的情况，如果不及时处理，很有可能对你的应用程序的业务逻辑产生严重的错误。

package com.wuk.thread;
    public class ThreadTest06 implements Runnable{ 
    
        private int num=0;
    
        @Override
        public void run() {
    
            test();
        }
    
        public static void main(String[] args) {
    
            ThreadTest06 threadTest06=new ThreadTest06();
            new Thread(threadTest06,"threadTest06").start();
    
        }
    
        public synchronized void  test(){
    
            while (true){
    
                        num++;
                        if(num==10){
                            Integer.parseInt("q");
                        }
                        try {
                            Thread.sleep(100);
                        } catch (InterruptedException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                        System.out.println("num="+num);
                    }
                }
    }

--------------------

## synchronized代码块 ##

使用synchronized声明的方法在某些情况下有弊端，比如A线程代用同步方法执行很长时间，那么B线程只能等待，这时候就可以利用synchronized优化执行时间，也就是减小锁的粒度。

案例1 :

package com.wuk.thread;
    
    public class ThreadTest08 { 
    
        public void method1(){
    
            synchronized (this) { 
                System.out.println("do method1...");
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
    
                    e.printStackTrace();
                }
            }
    
    
        }
    
        //类锁
        public void method2(){
            synchronized (ThreadTest08.class) {
    
                System.out.println("do method2...");
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
    
                    e.printStackTrace();
                }
            }       
        }
    
        private Object lock=new Object();
    
        public void method3(){ //任何对象锁
    
            synchronized (lock) {
                System.out.println("do method3...");
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
    
                    e.printStackTrace();
                }
            }
        }
    
        public static void main(String[] args) {
    
            final ThreadTest08 threadTest08=new ThreadTest08();
            Thread thread01=new Thread(new Runnable() {
    
                @Override
                public void run() {
    
                    threadTest08.method1();
                }
            });
    
            thread01.start();
    
            Thread thread02=new Thread(new Runnable() {
    
                @Override
                public void run() {
    
                    threadTest08.method2();
                }
            });
    
            thread02.start();
    
            Thread thread03=new Thread(new Runnable() {
    
                @Override
                public void run() {
    
                    threadTest08.method3();
                }
            });
    
            thread03.start();
        }
    }