Java高并发--------JDK并发包-------3

Posted 2020-12-07 梦想成为DALAO

JDK并发包

3.1同步控制

synchronized、obj.wait()、obj.notify()

3.1.1关键字synchronized的功能扩展：重入锁

java.util.concurrent.locks.ReentrantLock类来实现的

手动加锁：lock.lock()

手动解锁：lock.unlock()

重复锁：

　　lock.lock()

　　lock.lock()

　　　　操作

　　lock.unlock()

　　lock.unlock()

中断响应

如果一个线程正在等待锁，那么它依然可以收到一个通知，被告知无须等待，就可以爬了。

 

import java.util.concurrent.locks.ReentrantLock;

public class IntLock implements Runnable {
    public static ReentrantLock lock1 = new ReentrantLock();
    public static ReentrantLock lock2 = new ReentrantLock();
    int lock;

    public IntLock(int lock){
        this.lock = lock;
    }

    @Override
    public void run() {

        try {
            if (lock == 1){
                lock1.lockInterruptibly();
                Thread.sleep(500);
                lock2.lockInterruptibly();
            }else {
                lock2.lockInterruptibly();
                Thread.sleep(500);
                lock1.lockInterruptibly();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {

            if (lock1.isHeldByCurrentThread()){
                lock1.unlock();
            }
            if (lock2.isHeldByCurrentThread()){
                lock2.unlock();
            }
            System.out.println(Thread.currentThread().getId() + "线程退出");
        }
    }

    public static void main(String[] args) throws InterruptedException {

        IntLock r1 = new IntLock(1);
        IntLock r2 = new IntLock(2);

        Thread t1 = new Thread(r1);
        Thread t2 = new Thread(r2);
        t1.start();
        t2.start();
        Thread.sleep(1000);
        //中断其中一个线程
        t2.interrupt();


    }
}

lockInterruptibly
public void lockInterruptibly() throws InterruptedException
1）如果当前线程未被中断，则获取锁。

2）如果该锁没有被另一个线程保持，则获取该锁并立即返回，将锁的保持计数设置为 1。

3）如果当前线程已经保持此锁，则将保持计数加 1，并且该方法立即返回。

4）如果锁被另一个线程保持，则出于线程调度目的，禁用当前线程，并且在发生以下两种情况之一以
前，该线程将一直处于休眠状态：
1）锁由当前线程获得；或者

2）其他某个线程中断当前线程。

5）如果当前线程获得该锁，则将锁保持计数设置为 1。
如果当前线程：
1）在进入此方法时已经设置了该线程的中断状态；或者

2）在等待获取锁的同时被中断。

则抛出 InterruptedException，并且清除当前线程的已中断状态。


6）在此实现中，因为此方法是一个显式中断点，所以要优先考虑响应中断，而不是响应锁的普通获取或
重入获取。

指定者： 接口 Lock 中的 lockInterruptibly
抛出： InterruptedException 如果当前线程已中断。

锁申请等待限时

tryLock（等待时间， 单位)

带参数：就申请一段时间，没有申请成功就爬

不带参数：就是相当于时间为0，没有就直接爬

公平锁

就是先来后到等待咯

ReentrantLock lock = new ReentrantLock(true)

非公平锁，就随机

分类

锁：

　　lock()：直接锁，一直等

　　lockInterruptiby()：获得锁，但是优先响应中断

　　tryLock()：尝试获得锁，获取不到，就直接爬了

　　tryLock(long time, TimeUnit unit)：获得锁，等一会获取不到就直接爬

解锁

　　unlock()：释放锁

3.1.2重复锁的好搭档：Condition

Condition与ReentrantLock的关系，类似Object.wait()和Object.notify()的关系

void await()  //使线程等待，释放所有锁

void awaitUninterruptibly() //但是不会再等待过程中响应中断

long awatiNanos(long nanosTimeout) 

boolean await(long time, TimeUnit unit)

boolean awaitUntil(Date deadline)

void signal()  // 唤醒一个等待中的线程

void signalAll()  //唤醒所有线程

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class ReenterLockCondition implements Runnable{

    public static ReentrantLock lock = new ReentrantLock();
    public static Condition condition = lock.newCondition();
    @Override
    public void run() {
        try {
            lock.lock();
            condition.await();
            System.out.println("thread is going on");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) throws InterruptedException {

        ReenterLockCondition t1 = new ReenterLockCondition();
        Thread t = new Thread(t1);
        t.start();
        Thread.sleep(2000);

        //主线程设置唤醒
        lock.lock();
        condition.signal();
        lock.unlock();
    }
}

执行步骤：

　　t线程执行到await()，就等待

　　main线程获得锁，唤醒等待队列中的一个线程，释放锁

　　t线程被唤醒，执行！

3.1.3允许多个下次你哼同时访问：信号量（Semphore）

public Semaphore(int permits)

public Semaphore(int permits, boolean fair)  //第二参数指定是否公平