Java 线程——共享受限资源

最新推荐文章于 2024-06-07 22:50:19 发布

sjh_389510506

最新推荐文章于 2024-06-07 22:50:19 发布

阅读量393

点赞数

分类专栏： java线程数据共享文章标签： java线程数据共享

本文链接：https://blog.csdn.net/sjh_389510506/article/details/89303947

版权

java线程同时被 2 个专栏收录

2 篇文章 0 订阅

订阅专栏

数据共享

1 篇文章 0 订阅

订阅专栏

谈起线程，有很重要的一点是关于解决线程间数据同步，或者说资源的访问问题。

参考java编程思想书籍，在21章第三节开始讲有关共享资源问题，所以接下来探讨关于线程同步机制；解决线程并发引起的数据访问问题，实际上就要控制访问的顺序和确定相关的规则，一般的我们可以用以下方式去实现：

synchronized 关键字实现可以参考文章

synchronized 又分为同步方法和同步代码块

同步方法：

private synchronized void method(){

        // 在方法定义中加一个关键字synchronized
    }

情况分类：我们知道这些情况都是在多个线程的情况下，因为不是多线程，则就按顺序执行了，没有讨论的必要了。

一个实例，一次只能有一个线程进入非静态同步的方法
多个实例，可以同时访问同一个非静态同步的方法
多个实例，不能同时访问进入静态的同步方法——一次只能有一个类实例进入

一个实例，一次只能有一个线程进入非静态同步的方法

代码验证：

public class SyncObject {

    Object lock = new Object();

    public static synchronized void fun(){
        System.out.println(Thread.currentThread().getName() + " is running");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + " is stop");

    }



    private synchronized void fun1(){
        System.out.println("fun1" + Thread.currentThread().getName() + " is running");
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("fun1" + Thread.currentThread().getName() + " is stop");
    }

    private void fun2(){
        synchronized (lock){
            System.out.println("fun2" + Thread.currentThread().getName() + " is running");
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("fun2" + Thread.currentThread().getName() + " is stop");
        }
    }

class NewThread extends Thread {

    //static 保证是同一个实例 不会创建多次
    static SyncObject syncFunc = new SyncObject();

    @Override
    public void run() {
        syncFunc.fun();

//        aMethod();
//        bMethod();
    }

    public synchronized void aMethod(){
        System.out.println("NewThread Amethod start");
        try {
            sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("NewThread Amethod end");
    }


    public synchronized void bMethod(){
        System.out.println("NewThread Bmethod start");
        try {
            sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("NewThread Bmethod end");
    }
}

验证结果：

public static void main(String[] args) {
        NewThread newThread1 = new NewThread();
        NewThread newThread2 = new NewThread();
        NewThread newThread3 = new NewThread();
//
        newThread1.start();
        newThread2.start();
        newThread3.start();

}

结果显示：

Thread-0 is running
Thread-0 is stop
Thread-2 is running
Thread-2 is stop
Thread-1 is running
Thread-1 is stop

多个实例，能同时进入同一个非静态同步的方法——也就是说多个实例之间互相没有关系，互不干扰

代码验证：把NewThread类中的SyncObject 前的static 去掉，就会形成多个实例对象：

class NewThread extends Thread {

    SyncObject syncFunc = new SyncObject();

    @Override
    public void run() {
        syncFunc.fun();

//        aMethod();
//        bMethod();
    }

 ......

}

然后打印结果是：

Thread-0 is running
Thread-1 is running
Thread-2 is running
Thread-0 is stop
Thread-2 is stop
Thread-1 is stop

多个实例的线程进入静态的同步方法——一次只能有一个类实例进入

public class SyncObject {

    Object lock = new Object();

    //这里加一个static 变成访问静态方法
    public static synchronized void fun(){
        System.out.println(Thread.currentThread().getName() + " is running");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + " is stop");

    }

 ......

打印结果：

Thread-0 is running
Thread-0 is stop
Thread-2 is running
Thread-2 is stop
Thread-1 is running
Thread-1 is stop

对比结论：非静态和静态的区别主要在于（以同步方法为例）：
非静态的同步方法是锁定类的实例的，而静态的同步方法是锁定类的；

也就是说，对于非静态的同步方法，在同一时刻，一个类的一个实例中，只有一个线程能进入同步的方法。但是对于多个实例，每一个实例的一个线程都可以进入同一同步的方法。

同步方法块（也叫临界区）

 private void method(){
        //用关键字锁住方法部分实现
        synchronized (lock){
            .....
        }
    }

一、当两个并发线程访问同一个对象object中的具有相同锁的同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。
二、当一个线程访问object的一个synchronized(this)同步代码块时，另一个线程仍然可以访问该object中的非synchronized(this)同步代码块，但其他的synchronized(this)同步代码块方法被阻塞；

对比：

在这里插入图片描述

注：从表中及实现打印可以得到：synchronized void method() 和 synchronized (this) {} 锁住的对象是同一个对象。

voliate 关键字

volatile关键字为域变量的访问提供了一种免锁机制,相当于告诉虚拟机该域可能会被其他线程更新. 然后此变量不使用自己的工作内存，而是使用主存中的值，这样就避免了读写不一致的问题，具体的做法就是在变量前面加一个voliate 修饰符。这样线程间数据同步问题就解决了。

重入锁 ReentrantLock （源码解读）

提到锁还有一种锁，就是接口 Lock，它的常用实现类ReentrantLock 。比较二者

	synhiced	lock
语法	关键字	一个接口
锁的释放	执行完同步代码，释放锁	手动释放，在finally中，调用unlock
锁的获取	假设A线程获得锁，B线程等待。如果A线程阻塞，B线程会一直等待	分情况而定，Lock有多个锁获取的方式，具体下面会说道，大致就是可以尝试获得锁，线程可以不用一直等待
锁类型	可重入、非公平、不可中断	可重入可判断可公平（两者皆可）
性能	低，使用少量同步	高、可以同步大量代码

代码示例

class X {
 *   private final ReentrantLock lock = new ReentrantLock();
 *   // ...
 *
 *   public void m() {
 *     lock.lock();  // block until condition holds
 *     try {
 *       // ... method body
 *     } finally {
 *       lock.unlock()
 *     }
 *   }
 * }}<

该锁也叫显示锁，对比隐式锁synchrozied而言，我们可以在finally处理其他事情，而synchrozied 则不行。Reentrant中文和翻译为“重入”，则也叫重入锁，其概念指的是以线程为单位，当一个线程获取对象锁之后，这个线程可以再次获取本对象上的锁，而其他的线程是不可以的。其意义是防止死锁。

可重入和不可重入的理解参考ReentrantLock的源码，或者文章。其原理就是内部有一个计数器，统计线程进入该锁的次数并且关联占用该锁的线程，同一个线程每次进入的时候计数器加一，出去减一，直到为零被释放。Synorized 也是重入锁，系统JDK 没有提供不可重入锁，这种锁可以自己编写一个出来，另外由于ReentrantLock的源码，又有了公平锁和非公平锁，其区别就是线程在队列中是否按照FIFO的顺序进行处理，是的话就是公平锁，不是即为非公平锁。