Java锁的实例解析

最新推荐文章于 2024-03-05 22:01:54 发布

中单大魔王

最新推荐文章于 2024-03-05 22:01:54 发布

阅读量1k

点赞数 1

分类专栏： synchronized 文章标签：锁 synchronized

本文链接：https://blog.csdn.net/qq_33142257/article/details/76099689

版权

synchronized 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

锁的概念：

首先要知道锁是个什么东西，做什么用的；它的关键字是synchronized，英文翻译是‘同步的‘，没错，锁就是来控制同步的；为什么要控制同步呢，在多线程的情况下，都需要进入某个单例类中的一个方法，这时就得控制它们一个个的进入才行，否则几个线程同时进入方法体，后进的改变了参数，导致先进的线程中数据混乱；

我们可以把锁想象成接力棒，下一个选手要能够开始跑，那他必须拿到前一个人递给他的接力棒才能跑；锁也是这样，如果一个线程先进了方法体，并且锁住了，后续的线程只能在外面等待，等到前一个进程执行结束释放锁；

锁的实现：

1、锁定方法

/**
 * Created by zelei.fan on 2017/7/23.
 */
public class test implements Runnable{

    private static int index = 10;

    public synchronized void synchronizeMethod(){
        if(index > 0){
            System.out.println(Thread.currentThread().getName()+":"+index);
            index--;
        }
    }

    @Override
    public void run() {
        /*同步方法，虽然是处理同一个静态变量，但是如果有多个实例线程来访问该方法的时候并不能锁住该方法，
        * 不影响其他实例线程在同一时刻访问该方法，线程不安全
        * */
        synchronizeMethod();
    }

    public static void main(String[] args) {
        test test1 = new test();
        new Thread(test1).start();
        new Thread(test1).start();
        new Thread(test1).start();
        new Thread(test1).start();
        new Thread(test1).start();
        new Thread(test1).start();
        new Thread(test1).start();
        new Thread(test1).start();
        new Thread(test1).start();
        new Thread(test1).start();
    }
}

执行结果：

Thread-1:10
Thread-6:9
Thread-2:8
Thread-4:7
Thread-5:6
Thread-0:5
Thread-7:4
Thread-3:3
Thread-8:2
Thread-9:1
可以看到锁定方法后，数据没有混乱，每个线程取到的数没有相同的；但是要注意这是有前提的，该方法所在的类必须是单例才行，也就是在整个内存中只有一个实例，如果是多例的话数据就有问题了，下面我换成两个实例来访问：

public static void main(String[] args) {
        test test = new test();
        test test1 = new test();
        new Thread(test).start();
        new Thread(test1).start();
        new Thread(test).start();
        new Thread(test1).start();
        new Thread(test).start();
        new Thread(test1).start();
        new Thread(test).start();
        new Thread(test1).start();
        new Thread(test).start();
        new Thread(test1).start();
    }

打印结果：

Thread-0:10
Thread-2:9
Thread-1:10
Thread-3:7
Thread-5:6
Thread-6:6
Thread-8:4
Thread-4:3
Thread-7:3
Thread-9:1
线程0和线程1取到的数时相同，这种情况是线程不安全的；

所以当锁定方法时test的实例调用该方法则会形成互斥，实现线程同步；但是test的另一个实例可以任意的访问该方法，因为不是同一个实例；当某个线程获取到锁时，等到该线程执行完后才会释放锁

但是如果说，当前这个类就是需要多例的，那怎么实现同步呢，很简单，只要加上static就行了；让它变成静态方法，因为静态方法在初始化的时候就已经编译好了放在内存中，而且就只有这一个，不管所在类是不是多例；

/**
 * Created by zelei.fan on 2017/7/23.
 */
public class test implements Runnable{

    private static int index = 10;

    /*同步static方法*/
    public static synchronized void synchronizeStatic(){
        if(index > 0){
            System.out.println(Thread.currentThread().getName()+":"+index);
            index--;
        }
    }

    @Override
    public void run() {
        /*同步方法，虽然是处理同一个静态变量，但是如果有多个实例线程来访问该方法的时候并不能锁住该方法，
        * 不影响其他实例线程在同一时刻访问该方法，线程不安全
        * */
        synchronizeStatic();
    }

    public static void main(String[] args) {
        test test = new test();
        test test1 = new test();
        new Thread(test).start();
        new Thread(test1).start();
        new Thread(test).start();
        new Thread(test1).start();
        new Thread(test).start();
        new Thread(test1).start();
        new Thread(test).start();
        new Thread(test1).start();
        new Thread(test).start();
        new Thread(test1).start();
    }
}

打印结果：

Thread-2:10
Thread-4:9
Thread-6:8
Thread-0:7
Thread-3:6
Thread-7:5
Thread-5:4
Thread-9:3
Thread-8:2
Thread-1:1
从结果可以看到就算是多例，也不会导致数据的混乱；

2、锁定代码块，只对方法某个部分锁：

这时就会有疑问了，锁定方法的时候，锁定对象是方法，锁定个代码块的时候拿什么当锁呢，可以通过锁定一个变量，或者常量，或者是一个实例变量；

/**
 * Created by zelei.fan on 2017/7/23.
 */
public class test implements Runnable{

    private static int index = 10;

    private static final String Lock = "lock";/*常量*/

    private byte[] bytes = new byte[0];/*实例变量*/

    private String lock = "synchronized";/*成员变量*/

    public void synchronizeObject(){
        /*通过锁定一个变量，或者常量，或者是一个实例变量*/
        synchronized (lock){
            if (index > 0){
                System.out.println(Thread.currentThread().getName()+":"+index);
                index--;
            }
        }
    }

    @Override
    public void run() {
        /*同步方法，虽然是处理同一个静态变量，但是如果有多个实例线程来访问该方法的时候并不能锁住该方法，
        * 不影响其他实例线程在同一时刻访问该方法，线程不安全
        * */
        synchronizeObject();
    }

    public static void main(String[] args) {
        test test = new test();
        test test1 = new test();
        new Thread(test).start();
        new Thread(test1).start();
        new Thread(test).start();
        new Thread(test1).start();
        new Thread(test).start();
        new Thread(test1).start();
        new Thread(test).start();
        new Thread(test1).start();
        new Thread(test).start();
        new Thread(test1).start();
    }
}

三种锁定的结果：

Lock:

Thread-0:10
Thread-4:9
Thread-2:8
Thread-8:7
Thread-5:6
Thread-1:5
Thread-6:4
Thread-9:3
Thread-3:2
Thread-7:1

bytes:

Thread-6:10
Thread-1:10
Thread-5:8
Thread-9:7
Thread-3:6
Thread-0:5
Thread-2:4
Thread-7:3
Thread-4:2
Thread-8:1

lock:

Thread-0:10
Thread-1:9
Thread-2:8
Thread-3:7
Thread-9:6
Thread-5:5
Thread-4:4
Thread-6:3
Thread-7:2
Thread-8:1

上面例子要多执行几次，以为多线程是随机访问的，多执行几次结果比较靠谱；Lock是毋庸置疑的，它是一个常量，内存中只有这一个；bytes为什么不安全呢，如果是单例的话其实是安全的，但是多例的情况下就有问题了，每个实例中都会new一个byte，而且互相之间不干扰，也就是每个线程各自执行各自的，不互相排斥；而为什么lock安全呢，虽然是两个实例，但是lock变量指向的synchronized是同一个，只要常量池中存在的常量就不会再创建了；

结合上面案例，比较实用的就锁定静态方法或者是锁定静态常量；