多线程--synchronized同步锁用法及作用范围

最新推荐文章于 2024-07-09 15:38:01 发布

没有梦想何必远方。

最新推荐文章于 2024-07-09 15:38:01 发布

阅读量1k

点赞数

分类专栏： java

本文链接：https://blog.csdn.net/qq_41799291/article/details/86618628

版权

java 专栏收录该内容

26 篇文章 0 订阅

订阅专栏

Java 中的 synchronized 关键字可以在多线程环境下用来作为线程安全的同步锁。
synchronized 关键字主要有以下几种用法：

非静态方法的同步；
静态方法的同步；
代码块。

下面分对象锁和类锁来分别说明 synchronized 用法：

1.对象锁对象锁在一个类中可以有很多个
案例1：两个线程同时访问一个对象里的用synchronized关键字修饰的方法

package com.zhu.threaddemo.synchronizedtest;

public class TestSynchronized {

    public synchronized void minus() {
        int count = 5;
        for (int i = 0; i < 5; i++) {
            count--;
            System.out.println(Thread.currentThread().getName() + " - " + count);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
            }
        }
    }
}

package com.zhu.threaddemo.synchronizedtest;

public class Run {

    public static void main(String[] args) {
        final TestSynchronized testSynchronized =new TestSynchronized();

        //起两个线程
        Thread thread1 =new Thread(new Runnable() {
            @Override
            public void run() {
                testSynchronized.minus();
            }
        });

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

        //启动线程
        thread1.start();
        thread2.start();
    }

}

执行结果：

Thread-0 - 4
Thread-0 - 3
Thread-0 - 2
Thread-0 - 1
Thread-0 - 0
Thread-1 - 4
Thread-1 - 3
Thread-1 - 2
Thread-1 - 1
Thread-1 - 0

可以发现两个线程 thread1 和 thread2，同时访问对象的方法，由于该方法是 synchronized 关键字修饰的，那么这两个线程都需要获得该对象锁，一个获得后另一个线程必须等待。
（另：thread1 和 thread2 谁先执行并不一定）
本例对于对象锁进行了基础的解释。但是对象锁的范围是怎样的，对象的某个同步方法被一个线程访问后，其他线程能不能访问该对象的其他同步方法，以及是否可以访问对象的其他非同步方法呢，下面对两种进行验证：
案例2：在对象TestSynchronized中加一个用synchronized的方法

package com.zhu.threaddemo.synchronizedtest;

public class TestSynchronized {

    public synchronized void minus() {
        int count = 5;
        for (int i = 0; i < 5; i++) {
            count--;
            System.out.println(Thread.currentThread().getName() + " - " + count);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
            }
        }
    }

    public synchronized void minus2() {
        int count = 5;
        for (int i = 0; i < 5; i++) {
            count--;
            System.out.println(Thread.currentThread().getName() + " - " + count);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
            }
        }
    }
}

线程分别调用不同的同步方法

package com.zhu.threaddemo.synchronizedtest;

public class Run {

    public static void main(String[] args) {
        final TestSynchronized testSynchronized =new TestSynchronized();

        //起两个线程
        Thread thread1 =new Thread(new Runnable() {
            @Override
            public void run() {
                testSynchronized.minus();
            }
        });

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

        //启动线程
        thread1.start();
        thread2.start();
    }

}

结果为：

Thread-0 - 4
Thread-0 - 3
Thread-0 - 2
Thread-0 - 1
Thread-0 - 0
Thread-1 - 4
Thread-1 - 3
Thread-1 - 2
Thread-1 - 1
Thread-1 - 0

可以看到，某个线程得到了对象锁之后，该对象的其他同步方法是锁定的，其他线程是无法访问的。
案例2：是否能访问非同步方法呢
把对象TestSynchronized中的一个方法改成非同步的

package com.zhu.threaddemo.synchronizedtest;

public class TestSynchronized {

    public synchronized void minus() {
        int count = 5;
        for (int i = 0; i < 5; i++) {
            count--;
            System.out.println(Thread.currentThread().getName() + " - " + count);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
            }
        }
    }

    public  void minus2() {
        int count = 5;
        for (int i = 0; i < 5; i++) {
            count--;
            System.out.println(Thread.currentThread().getName() + " - " + count);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
            }
        }
    }
}

执行结果为：

Thread-1 - 4
Thread-0 - 4
Thread-1 - 3
Thread-0 - 3
Thread-1 - 2
Thread-0 - 2
Thread-1 - 1
Thread-0 - 1
Thread-1 - 0
Thread-0 - 0

可以看到可以看到，结果是交替的，说明线程是交替执行的，说明如果某个线程得到了对象锁，但是另一个线程还是可以访问没有进行同步的方法或者代码。进行了同步的方法（加锁方法）和没有进行同步的方法（普通方法）是互不影响的，一个线程进入了同步方法，得到了对象锁，其他线程还是可以访问那些没有同步的方法（普通方法）。

2.类锁
类锁需要 synchronized 来修饰静态 static 方法，写法如下：

public static synchronized void test(){
        // TODO
    }

或者使用代码块，需引用当前的类：

 public static void test(){
        synchronized (TestSynchronized.class) {
            // TODO
        }
    }

举例说明类锁的作用：

两个线程访问一个对象的一个用static修饰的synchronized方法

package com.zhu.threaddemo.synchronizedtest;

public class TestSynchronized1 {


    public static synchronized void minus() {
        int count = 5;
        for (int i = 0; i < 5; i++) {
            count--;
            System.out.println(Thread.currentThread().getName() + " - " + count);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
            }
        }
    }


}

package com.zhu.threaddemo.synchronizedtest;

public class Run1 {

    public static void main(String[] args) {
        final TestSynchronized1 testSynchronized =new TestSynchronized1();

        //起两个线程
        Thread thread1 =new Thread(new Runnable() {
            @Override
            public void run() {
                testSynchronized.minus();
            }
        });

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

        //启动线程
        thread1.start();
        thread2.start();
    }

}

结果：

Thread-0 - 4
Thread-0 - 3
Thread-0 - 2
Thread-0 - 1
Thread-0 - 0
Thread-1 - 4
Thread-1 - 3
Thread-1 - 2
Thread-1 - 1
Thread-1 - 0

可以看到，类锁和对象锁其实是一样的，由于静态方法是类所有对象共用的，所以进行同步后，该静态方法的锁也是所有对象唯一的。每次只能有一个线程来访问对象的该非静态同步方法。
类锁的作用和对象锁类似，但是作用范围是否和对象锁一致呢，下面看对象锁和类锁是否等同：
修改类，两个同步方法，其中一个是静态的：

一个是类锁一个是对象锁

package com.zhu.threaddemo.synchronizedtest;

public class TestSynchronized1 {


    public static synchronized void minus() {
        int count = 5;
        for (int i = 0; i < 5; i++) {
            count--;
            System.out.println(Thread.currentThread().getName() + " - " + count);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
            }
        }
    }
    public  synchronized void minus2() {
        int count = 5;
        for (int i = 0; i < 5; i++) {
            count--;
            System.out.println(Thread.currentThread().getName() + " - " + count);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
            }
        }
    }


}

package com.zhu.threaddemo.synchronizedtest;

public class Run1 {

    public static void main(String[] args) {
        final TestSynchronized1 testSynchronized =new TestSynchronized1();

        //起两个线程
        Thread thread1 =new Thread(new Runnable() {
            @Override
            public void run() {
                testSynchronized.minus();
            }
        });

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

        //启动线程
        thread1.start();
        thread2.start();
    }

}

执行结果

Thread-0 - 4
Thread-1 - 4
Thread-1 - 3
Thread-0 - 3
Thread-0 - 2
Thread-1 - 2
Thread-0 - 1
Thread-1 - 1
Thread-0 - 0
Thread-1 - 0

可以看到两个线程是交替进行的，也就是说类锁和对象锁是不一样的锁，是互相独立的。

没有梦想何必远方。

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
多线程--synchronized同步锁用法及作用范围

Java 中的 synchronized 关键字可以在多线程环境下用来作为线程安全的同步锁。synchronized 关键字主要有以下几种用法：非静态方法的同步；静态方法的同步；代码块。下面分对象锁和类锁来分别说明 synchronized 用法：1.对象锁对象锁在一个类中可以有很多个案例1：两个线程同时访问一个对象里的用synchronized关键字修饰的方法packa...
复制链接

扫一扫

专栏目录