android--同步锁

(一)同步方法

1、静态方法同步——测试


TestModel.java

public class TestModel

{

    public static void function1()//方法1

    {

        try

        {

            Thread.sleep(5000);//延迟5s

        }

        catch (InterruptedException e)

        {

        }

        System.out.println("in function----1");//打出日志

    }

    public static void function2()//方法2

    {

        try

        {

            Thread.sleep(5000);//延迟5s

        }

        catch (InterruptedException e)

        {

        }

        System.out.println("in function----2");//打出日志

    }

    public static void function3()//方法3

    {

        try

        {

            Thread.sleep(5000);//延迟5s

        }

        catch (InterruptedException e)

        {

        }

        System.out.println("in function----3");//打出日志

    }

}



TestMain.java

public class TestMain

{

    public static void main(String[] args)

    {

        new Run1().start();//启动线程1

        new Run2().start();//启动线程2

        new Run3().start();//启动线程3

    }

    static class Run1 extends Thread//线程1

    {

        @Override

        public void run()

        {

            TestModel.function1();//调用TestModel静态同步方法1

        }

    }


    static class Run2 extends Thread//线程2

    {

        @Override

        public void run()

        {

            TestModel.function2();//调用TestModel静态同步方法2

        }

    }


    static class Run3 extends Thread//线程3

    {

        @Override

        public void run()

        {

            TestModel.function3();//调用TestModel静态同步方法3

        }

    }

}


测试结果:

静态方法的同步,就是用类本身(TestModel.class)作为锁,当class被某个静态同步方法锁定的时候,其他静态同步方法也想使用该class达到同步的效果,只有等待。

2、非静态方法同步——测试 


TestModel.java

public class TestModel

{

    public synchronized void function1()//方法1

    {

        try

        {

            Thread.sleep(5000);//延迟5s

        }

        catch (InterruptedException e)

        {

        }

        System.out.println("in function----1");//打出日志

    }

    public synchronized void function2()//方法2

    {

        try

        {

            Thread.sleep(5000);//延迟5s

        }

        catch (InterruptedException e)

        {

        }

        System.out.println("in function----2");//打出日志

    }

    public synchronized void function3()//方法3

    {

        try

        {

            Thread.sleep(5000);//延迟5s

        }

        catch (InterruptedException e)

        {

        }

        System.out.println("in function----3");//打出日志

    }

}



TestMain.java

public class TestMain

{

    static TestModel testModel;//使用同一个实例


    public static void main(String[] args)

    {

        testModel = new TestModel();


        new Run1().start();//启动线程1

        new Run2().start();//启动线程2

        new Run3().start();//启动线程3

    }

    static class Run1 extends Thread//线程1

    {

        @Override

        public void run()

        {

            testModel.function1();//调用testModel非静态同步方法1

        }

    }


    static class Run2 extends Thread//线程2

    {

        @Override

        public void run()

        {

            testModel.function2();//调用testModel非静态同步方法2

        }

    }


    static class Run3 extends Thread//线程3

    {

        @Override

        public void run()

        {

            testModel.function3();//调用testModel非静态同步方法3

        }

    }

}


测试结果:

上面使用的是同一实例进行调用,如果使用不同的实例调用,测试结果如下:


TestModel.java

public class TestMain

{

    static TestModel testModel1;//实例1

    static TestModel testModel2;//实例2

    static TestModel testModel3;//实例3


    public static void main(String[] args)

    {

        testModel1 = new TestModel();

        testModel2 = new TestModel();

        testModel3 = new TestModel();


        new Run1().start();//启动线程1

        new Run2().start();//启动线程2

        new Run3().start();//启动线程3

    }

    static class Run1 extends Thread//线程1

    {

        @Override

        public void run()

        {

            testModel1.function1();//调用testModel1非静态同步方法1

        }

    }


    static class Run2 extends Thread//线程2

    {

        @Override

        public void run()

        {

            testModel2.function1();//调用testModel2非静态同步方法1

        }

    }


    static class Run3 extends Thread//线程3

    {

        @Override

        public void run()

        {

            testModel3.function1();//调用testModel3非静态同步方法1

        }

    }

}


测试结果:

非静态同步方法,用调用者作为同步锁(类的一个实例);

所以在同一实例在不同线程中调用不同的非静态同步方法时,出现了等待的情况;

当线程中使用不同的实例进行非静态同步方法调用时,由于锁定的对象不同,所以互不影响。

(二)同步方法块

同步方法块,锁定的对象并不固定,开发人员可根据自身业务需求进行使用不同的锁,这里只简述锁定对象实例的情况。

1、同步方法块——单例模式锁定


TestModel.java

public class TestModel

{

    private static TestModel instance = new TestModel();


    private TestModel()

    {

    }


    public static TestModel getInstance()

    {

        return instance;//单例模式

    }


    public void function1()//方法1

    {

        synchronized(instance)//这里写成this,效果一样

        {

            try

            {

                Thread.sleep(5000);//延迟5s

            }

            catch (InterruptedException e)

            {

            }

            System.out.println("in function----1");//打出日志

        }

    }

    public void function2()//方法2

    {

        synchronized(instance)//这里写成this,效果一样

        {

            try

            {

                Thread.sleep(5000);//延迟5s

            }

            catch (InterruptedException e)

            {

            }

            System.out.println("in function----2");//打出日志

        }

    }

    public synchronized void function3()//方法3

    {

        synchronized(instance)//这里写成this,效果一样

        {

            try

            {

                Thread.sleep(5000);//延迟5s

            }

            catch (InterruptedException e)

            {

            }

            System.out.println("in function----3");//打出日志

        }

    }

}



TestMain.java

public class TestMain

{

    static TestModel testModel1;//同一单例

    static TestModel testModel2;//同一单例

    static TestModel testModel3;//同一单例


    public static void main(String[] args)

    {

        testModel1 = TestModel.getInstance();

        testModel2 = TestModel.getInstance();

        testModel3 = TestModel.getInstance();


        new Run1().start();//启动线程1

        new Run2().start();//启动线程2

        new Run3().start();//启动线程3

    }

    static class Run1 extends Thread//线程1

    {

        @Override

        public void run()

        {

            testModel1.function1();//调用testModel1方法1

        }

    }


    static class Run2 extends Thread//线程2

    {

        @Override

        public void run()

        {

            testModel2.function2();//调用testModel2方法2

        }

    }


    static class Run3 extends Thread//线程3

    {

        @Override

        public void run()

        {

            testModel3.function3();//调用testModel3方法3

        }

    }

}


测试结果:

同步方法块使用单例作为锁的时候,效果等同于静态同步方法;因为单例模式下,意味着只有一把锁。

2、同步方法块——非单例模式锁定


TestModel.java

public class TestModel

{

    public void function1()//方法1

    {

        synchronized(this)//效果等同于非静态同步方法

        {

            try

            {

                Thread.sleep(5000);//延迟5s

            }

            catch (InterruptedException e)

            {

            }

            System.out.println("in function----1");//打出日志

        }

    }

    public void function2()//方法2

    {

        synchronized(this)//效果等同于非静态同步方法

        {

            try

            {

                Thread.sleep(5000);//延迟5s

            }

            catch (InterruptedException e)

            {

            }

            System.out.println("in function----2");//打出日志

        }

    }

    public synchronized void function3()//方法3

    {

        synchronized(this)//效果等同于非静态同步方法

        {

            try

            {

                Thread.sleep(5000);//延迟5s

            }

            catch (InterruptedException e)

            {

            }

            System.out.println("in function----3");//打出日志

        }

    }

}



TestMain.java

public class TestMain

{

    static TestModel testModel1;//单例1

    static TestModel testModel2;//单例2

    static TestModel testModel3;//单例3


    public static void main(String[] args)

    {

        testModel1 = new TestModel();

        testModel2 = new TestModel();

        testModel3 = new TestModel();


        new Run1().start();//启动线程1

        new Run2().start();//启动线程2

        new Run3().start();//启动线程3

    }

    static class Run1 extends Thread//线程1

    {

        @Override

        public void run()

        {

            testModel1.function1();//调用testModel1方法1

        }

    }


    static class Run2 extends Thread//线程2

    {

        @Override

        public void run()

        {

            testModel2.function2();//调用testModel2方法2

        }

    }


    static class Run3 extends Thread//线程3

    {

        @Override

        public void run()

        {

            testModel3.function3();//调用testModel3方法3

        }

    }

}


测试结果:

同步方法块使用非单例作为锁的时候,效果等同于非静态同步方法;锁定的对象为实际调用的实例。

现在修改TestMain.java如下:


TestModel.java

public class TestMain

{

    static TestModel testModel1;//单例1

    static TestModel testModel2;//引用1

    static TestModel testModel3;//引用1


    public static void main(String[] args)

    {

        testModel1 = new TestModel();

        testModel2 = testModel1;

        testModel3 = testModel1;


        new Run1().start();//启动线程1

        new Run2().start();//启动线程2

        new Run3().start();//启动线程3

    }

    static class Run1 extends Thread//线程1

    {

        @Override

        public void run()

        {

            testModel1.function1();//调用testModel1方法1

        }

    }


    static class Run2 extends Thread//线程2

    {

        @Override

        public void run()

        {

            testModel2.function2();//调用testModel2方法2

        }

    }


    static class Run3 extends Thread//线程3

    {

        @Override

        public void run()

        {

            testModel3.function3();//调用testModel3方法3

        }

    }

}


测试结果:

由于锁定的对象为同一个实例,出现了等待的现象。

三、总结

同步的出现是为了确保数据操作的正确性,而同步的核心即在于锁的合理使用,明白了锁的使用原理,同步自然也不成问题。

推荐阅读更多精彩内容