【synchronized 关键字修饰静态、非静态方法的区别】

synchronized 锁

我之前写过两篇关于多线程的博客，对synchronized
锁的实现机制有详细的解释，有兴趣的朋友可以先跳转：多线程

测试总结：

多线程使用同一个对象，只允许同时使用一个对象锁，一个类锁，其他操作搭配都互斥，只能等前一个线程解锁才能让下一个线程使用；
多线程分别 new 一个对象，允许同时使用任意的对象锁，也允许对象锁和一个类锁同时使用，但是类锁不能够同时使用，会互斥，只能等前一个线程解锁才能让下一个线程使用；

下面我们来分组测试：

我们先准备一个含有对象锁和类锁的类：MSynchronized


public class MSynchronized {
    
    
    public synchronized void method1(String name) throws InterruptedException {
    
    
        int i = 0;
        while (true) {
    
    
            i++;
            System.out.println(name + "我是方法1，当前数字是" + i);
            if (i > 4) {
    
    
                System.out.println(name + "我是方法1，退出");
                break;
            }
            Thread.sleep(1000);
        }
    }

    public synchronized void method2(String name) throws InterruptedException {
    
    
        int i = 0;
        while (true) {
    
    
            i++;
            System.out.println(name + "我是方法2，当前数字是" + i);
            if (i > 4) {
    
    
                System.out.println(name + "我是方法2，退出");
                break;
            }
            Thread.sleep(1000);
        }


    }

    public static synchronized void method3(String name) throws InterruptedException {
    
    
        int i = 0;
        while (true) {
    
    
            i++;
            System.out.println(name + "我是方法3，当前数字是" + i);
            if (i > 4) {
    
    
                System.out.println(name + "我是方法3，退出");
                break;
            }
            Thread.sleep(1000);
        }


    }

    public static synchronized void method4(String name) throws InterruptedException {
    
    
        int i = 0;
        while (true) {
    
    
            i++;
            System.out.println(name + "我是方法4，当前数字是" + i);
            if (i > 4) {
    
    
                System.out.println(name + "我是方法4，退出");
                break;
            }
            Thread.sleep(1000);
        }

    }
}

测试类

public class SynT {
    
    

    public static void main(String[] args){
    
    
    
    }
}

测试一： 多线程使用同一个对象

同时使用同一个对象锁

package com.example.javabaisc.lock;

public class SynT {
    
    

    public static void main(String[] args){
    
    
        //共用对象
        MSynchronized mSynchronized = new MSynchronized();

        Thread s1 = new Thread(new Runnable() {
    
    
            @Override
            public void run() {
    
    
                try {
    
    
//                    System.out.println("=========我是线程1==========");
                    mSynchronized.method1("我是线程1");
                } catch (InterruptedException e) {
    
    
                    e.printStackTrace();
                }

            }
        });
        Thread s2 = new Thread(new Runnable() {
    
    
            @Override
            public void run() {
    
    
                try {
    
    
//                    System.out.println("==========我是线程2========");
                    mSynchronized.method1("我是线程2");
                } catch (InterruptedException e) {
    
    
                    e.printStackTrace();
                }

            }
        });

        //启动
        s1.start();
        s2.start();
    }
}

结果：
在这里插入图片描述
结论：互斥，不能同时使用

同时使用不同的的对象锁


public class SynT {
    
    

    public static void main(String[] args){
    
    
        //共用对象
        MSynchronized mSynchronized = new MSynchronized();

        Thread s1 = new Thread(new Runnable() {
    
    
            @Override
            public void run() {
    
    
                try {
    
    
//                    System.out.println("=========我是线程1==========");
                    mSynchronized.method1("我是线程1");
                } catch (InterruptedException e) {
    
    
                    e.printStackTrace();
                }

            }
        });
        Thread s2 = new Thread(new Runnable() {
    
    
            @Override
            public void run() {
    
    
                try {
    
    
//                    System.out.println("==========我是线程2========");
                    mSynchronized.method2("我是线程2");
                } catch (InterruptedException e) {
    
    
                    e.printStackTrace();
                }

            }
        });

        //启动
        s1.start();
        s2.start();
    }
}

运行结果：
在这里插入图片描述
结论：互斥，不能同时使用

一个线程使用对象锁，一个使用类锁


public class SynT {
    
    

    public static void main(String[] args){
    
    
        //共用对象
        MSynchronized mSynchronized = new MSynchronized();

        Thread s1 = new Thread(new Runnable() {
    
    
            @Override
            public void run() {
    
    
                try {
    
    
//                    System.out.println("=========我是线程1==========");
                    mSynchronized.method1("我是线程1");
                } catch (InterruptedException e) {
    
    
                    e.printStackTrace();
                }

            }
        });
        Thread s2 = new Thread(new Runnable() {
    
    
            @Override
            public void run() {
    
    
                try {
    
    
//                    System.out.println("==========我是线程2========");
                    mSynchronized.method4("我是线程2");
                } catch (InterruptedException e) {
    
    
                    e.printStackTrace();
                }

            }
        });

        //启动
        s1.start();
        s2.start();
    }
}

运行结果：
在这里插入图片描述
结论：可以同时使用；

同时使用同一个类锁


public class SynT {
    
    

    public static void main(String[] args){
    
    
        //共用对象
        MSynchronized mSynchronized = new MSynchronized();

        Thread s1 = new Thread(new Runnable() {
    
    
            @Override
            public void run() {
    
    
                try {
    
    
//                    System.out.println("=========我是线程1==========");
                    mSynchronized.method4("我是线程1");
                } catch (InterruptedException e) {
    
    
                    e.printStackTrace();
                }

            }
        });
        Thread s2 = new Thread(new Runnable() {
    
    
            @Override
            public void run() {
    
    
                try {
    
    
//                    System.out.println("==========我是线程2========");
                    mSynchronized.method4("我是线程2");
                } catch (InterruptedException e) {
    
    
                    e.printStackTrace();
                }

            }
        });

        //启动
        s1.start();
        s2.start();
    }
}

运行结果：
在这里插入图片描述
结论：互斥，不能同时使用

同时使用不同的的类锁


public class SynT {
    
    

    public static void main(String[] args){
    
    
        //共用对象
        MSynchronized mSynchronized = new MSynchronized();

        Thread s1 = new Thread(new Runnable() {
    
    
            @Override
            public void run() {
    
    
                try {
    
    
//                    System.out.println("=========我是线程1==========");
                    mSynchronized.method3("我是线程1");
                } catch (InterruptedException e) {
    
    
                    e.printStackTrace();
                }

            }
        });
        Thread s2 = new Thread(new Runnable() {
    
    
            @Override
            public void run() {
    
    
                try {
    
    
//                    System.out.println("==========我是线程2========");
                    mSynchronized.method4("我是线程2");
                } catch (InterruptedException e) {
    
    
                    e.printStackTrace();
                }

            }
        });

        //启动
        s1.start();
        s2.start();
    }
}

运行结果：
在这里插入图片描述
结论：互斥，不能同时使用

测试二： 多线程分别一个对象

同时使用同一个对象锁

package com.example.javabaisc.lock;

public class SynT {
    
    

    public static void main(String[] args){
    
    

        Thread s1 = new Thread(new Runnable() {
    
    
            @Override
            public void run() {
    
    
                try {
    
    
//                    System.out.println("=========我是线程1==========");
                    MSynchronized mSynchronized = new MSynchronized();
                    mSynchronized.method1("我是线程1");
                } catch (InterruptedException e) {
    
    
                    e.printStackTrace();
                }

            }
        });
        Thread s2 = new Thread(new Runnable() {
    
    
            @Override
            public void run() {
    
    
                try {
    
    
//                    System.out.println("==========我是线程2========");
                    MSynchronized mSynchronized2 = new MSynchronized();
                    mSynchronized2.method1("我是线程2");
                } catch (InterruptedException e) {
    
    
                    e.printStackTrace();
                }

            }
        });

        //启动
        s1.start();
        s2.start();
    }
}

运行结果：
在这里插入图片描述
结论：可以同时使用

同时使用不同的的对象锁

package com.example.javabaisc.lock;

public class SynT {
    
    

    public static void main(String[] args){
    
    

        Thread s1 = new Thread(new Runnable() {
    
    
            @Override
            public void run() {
    
    
                try {
    
    
//                    System.out.println("=========我是线程1==========");
                    MSynchronized mSynchronized = new MSynchronized();
                    mSynchronized.method1("我是线程1");
                } catch (InterruptedException e) {
    
    
                    e.printStackTrace();
                }

            }
        });
        Thread s2 = new Thread(new Runnable() {
    
    
            @Override
            public void run() {
    
    
                try {
    
    
//                    System.out.println("==========我是线程2========");
                    MSynchronized mSynchronized2 = new MSynchronized();
                    mSynchronized2.method2("我是线程2");
                } catch (InterruptedException e) {
    
    
                    e.printStackTrace();
                }

            }
        });

        //启动
        s1.start();
        s2.start();
    }
}

运行结果：
在这里插入图片描述
结论：可以同时使用

一个线程使用对象锁，一个使用类锁

package com.example.javabaisc.lock;

public class SynT {
    
    

    public static void main(String[] args){
    
    

        Thread s1 = new Thread(new Runnable() {
    
    
            @Override
            public void run() {
    
    
                try {
    
    
//                    System.out.println("=========我是线程1==========");
                    MSynchronized mSynchronized = new MSynchronized();
                    mSynchronized.method1("我是线程1");
                } catch (InterruptedException e) {
    
    
                    e.printStackTrace();
                }

            }
        });
        Thread s2 = new Thread(new Runnable() {
    
    
            @Override
            public void run() {
    
    
                try {
    
    
//                    System.out.println("==========我是线程2========");
                    MSynchronized mSynchronized2 = new MSynchronized();
                    mSynchronized2.method4("我是线程2");
                } catch (InterruptedException e) {
    
    
                    e.printStackTrace();
                }

            }
        });

        //启动
        s1.start();
        s2.start();
    }
}

运行结果：
在这里插入图片描述
结论：可以同时使用

同时使用同一个类锁

package com.example.javabaisc.lock;

public class SynT {
    
    

    public static void main(String[] args){
    
    

        Thread s1 = new Thread(new Runnable() {
    
    
            @Override
            public void run() {
    
    
                try {
    
    
//                    System.out.println("=========我是线程1==========");
                    MSynchronized mSynchronized = new MSynchronized();
                    mSynchronized.method4("我是线程1");
                } catch (InterruptedException e) {
    
    
                    e.printStackTrace();
                }

            }
        });
        Thread s2 = new Thread(new Runnable() {
    
    
            @Override
            public void run() {
    
    
                try {
    
    
//                    System.out.println("==========我是线程2========");
                    MSynchronized mSynchronized2 = new MSynchronized();
                    mSynchronized2.method4("我是线程2");
                } catch (InterruptedException e) {
    
    
                    e.printStackTrace();
                }

            }
        });

        //启动
        s1.start();
        s2.start();
    }
}

运行结果：
在这里插入图片描述
结论：互斥，不能同时使用

同时使用不同的的类锁

package com.example.javabaisc.lock;

public class SynT {
    
    

    public static void main(String[] args){
    
    

        Thread s1 = new Thread(new Runnable() {
    
    
            @Override
            public void run() {
    
    
                try {
    
    
//                    System.out.println("=========我是线程1==========");
                    MSynchronized mSynchronized = new MSynchronized();
                    mSynchronized.method3("我是线程1");
                } catch (InterruptedException e) {
    
    
                    e.printStackTrace();
                }

            }
        });
        Thread s2 = new Thread(new Runnable() {
    
    
            @Override
            public void run() {
    
    
                try {
    
    
//                    System.out.println("==========我是线程2========");
                    MSynchronized mSynchronized2 = new MSynchronized();
                    mSynchronized2.method4("我是线程2");
                } catch (InterruptedException e) {
    
    
                    e.printStackTrace();
                }

            }
        });

        //启动
        s1.start();
        s2.start();
    }
}

运行结果：在这里插入图片描述
结论：互斥，不能同时使用

测试总结：

多线程使用同一个对象，只允许同时使用一个对象锁，一个类锁，其他操作搭配都互斥，只能等前一个线程解锁才能让下一个线程使用；
多线程分别 new 一个对象，允许同时使用任意的对象锁，也允许对象锁和一个类锁同时使用，但是类锁不能够同时使用，会互斥，只能等前一个线程解锁才能让下一个线程使用；

【synchronized 关键字修饰静态、非静态方法的区别】

synchronized 锁

猜你喜欢