java之结合代码理解synchronized关键字

Posted alex_wongh

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了java之结合代码理解synchronized关键字相关的知识,希望对你有一定的参考价值。

为了保证数据的一致性即实现线程的安全性,java虚拟机提供了同步和锁机制。synchronized关键字是最基本的互斥同步手段。除此之外,还可以使用java.util.concurrent包中的重入锁(ReentrantLock)来实现同步。相比synchronized,ReentrantLock增加了一些高级功能,主要有等待可中断、可实现公平锁、锁可以绑定多个条件等。

见SynchronizedDemo.java的源码理解synchronized

/**
 * Synchronized理解:
 *    根据如下4个例子总结如下:
 * Synchronized修饰的方法和Synchronized(this)修饰的代码块功能是一样的,当使用Synchronized修饰的方法或Synchronized(this)修饰的代码块被调用时,当前的实例对象被锁住,因此没有其他线程可以调用该实例对象的这个或任何其他的Synchronized修饰的方法和Synchronized(this)修饰的代码块
 * static Synchronized修饰的方法和Synchronized(*.class)修饰的代码块功能是一样的,当使用static Synchronized修饰的方法或Synchronized(*.class)修饰的代码块被调用时,当前的类对象(例子中的是Sync.class对象)被锁住,因此没有其他线程可以调用同一个类的的这个或任何其他的static Synchronized修饰的方法和Synchronized(*.class)修饰的代码块
 **/
public class SynchronizedDemo{
    /**
     * 例1:
     * 同一个对象:
     * 当一个线程进入一个对象A的synchronized方法的同时,其它线程不能进入该对象的任何synchronized方法
     **/
    private void showSynchronizedResult1(){
        final Sync testSync1 = new Sync();
     
        Thread thread1 = new Thread(new Runnable(){
            @Override
            public void run(){
                testSync1.run1();
            }
        });

        Thread thread2 = new Thread(new Runnable(){
            @Override
            public void run(){
                testSync1.run2();
            }
        });

        thread1.start();
        thread2.start();
    }
    
    /**
     * 例2:
     * 同一个对象:
     * 当一个线程进入一个对象A的synchronized方法的同时,其它线程可以进入该对象的普通方法
     **/
    private void showSynchronizedResult2(){
        final Sync testSync1 = new Sync();
     
        Thread thread1 = new Thread(new Runnable(){
            @Override
            public void run(){
                testSync1.run1();
            }
        });

        Thread thread3 = new Thread(new Runnable(){
            @Override
            public void run(){
                testSync1.run3();
            }
        });

        thread1.start();
        thread3.start();
    }
    
    /**
     * 例3:
     * 不同对象 
     * 当一个线程进入一个对象A的synchronized方法的同时,其它线程可以进入其他对象的synchronized方法,互不影响
     **/
    private void showSynchronizedResult3(){
        final Sync testSync1 = new Sync();
        final Sync testSync2 = new Sync();
     
        Thread thread1 = new Thread(new Runnable(){
            @Override
            public void run(){
                testSync1.run1();
            }
        });

        Thread thread2 = new Thread(new Runnable(){
            @Override
            public void run(){
                testSync2.run2();
            }
        });

        thread1.start();
        thread2.start();
    }
    
    /**
     * 例4:
     * 当一个线程进入一个static synchronized方法的同时,其它线程不可以进入任何的static synchronized方法
     **/
    private void showStaticSynchronizedResult4(){
        Thread thread1 = new Thread(new Runnable(){
            @Override
            public void run(){
                Sync.run4();
            }
        });

        Thread thread2 = new Thread(new Runnable(){
            @Override
            public void run(){
                Sync.run5();
            }
        });

        thread1.start();
        thread2.start();
    }
    
    public static void main(String args[]){
        // 例1:多线程下同一对象的多个Synchronized方法
        new SynchronizedDemo().showSynchronizedResult1();
        
        // 例2:多线程下同一对象的Synchronized方法和普通方法
        //new SynchronizedDemo().showSynchronizedResult2();
        
        // 例3:多线程下不同对象的Synchronized方法
        //new SynchronizedDemo().showSynchronizedResult3();
        
        // 例4:多线程下的多个static Synchronized方法
        //new SynchronizedDemo().showStaticSynchronizedResult4();
    }
}

class Sync{
    public synchronized void run1(){
        for (int i = 0; i < 5; i++){
            System.out.println("execute run1");
            sleepOneSec();
        }
    }

    public synchronized void run2(){
        for (int i = 0; i < 5; i++){
            System.out.println("execute run2");
            sleepOneSec();
        }
    }
    
    public void run3(){
        for (int i = 0; i < 5; i++){
            System.out.println("execute run3");
            sleepOneSec();
        }
    }
    
    public static synchronized void run4(){
        for (int i = 0; i < 5; i++){
            System.out.println("execute run4");
            sleepOneSec();
        }
    }

    public static synchronized void run5(){
        for (int i = 0; i < 5; i++){
            System.out.println("execute run5");
            sleepOneSec();
        }
    }
    
    private static void sleepOneSec(){
        try{
            Thread.sleep(1000);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}

 

以上是关于java之结合代码理解synchronized关键字的主要内容,如果未能解决你的问题,请参考以下文章

Java多线程之深入理解synchronize关键字

彻底理解Java并发编程之Synchronized关键字实现原理剖析

彻底理解Java并发编程之Synchronized关键字实现原理剖析

java关键字之synchronized

Java多线程之synchronized关键字

JAVA并发之synchronized关键字