package com.dingyu2;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
 * Reentrant n.再进入
 * ReentrantLock 一个可重入互斥Lock具有与使用synchronized方法和语句访问的隐式监视锁相同的基本行为和语义，但具有扩展功能。（从jdk1.8中文版复制而来）
 * 可以完成synchronized相同的作用，但必须手动释放锁
 * @author dingyu
 *
 */
public class ReentrantLock1 {
    private Lock lock = new ReentrantLock();
    public void m1() {
        try {
            lock.lock();//synchronized(this)类似，锁定的是堆的对象
            for (int i = 0; i < 10; i++)
                System.out.println("m1-" + i);
        } catch (Exception e) {
            System.out.println("m1启动");
        } finally {
            System.out.println("m1结束");
            lock.unlock();
        }
    }
    public void m2() {
        try {
            lock.lock();
            for (int i = 0; i < 10; i++)
                System.out.println("m2-" + i);
        } catch (Exception e) {
            System.out.println("m2启动");
        } finally {
            System.out.println("m2结束");
            lock.unlock();
        }
    }
    public static void main(String[] args) {
        ReentrantLock1 reentrantLock1 = new ReentrantLock1();
        new Thread(() -> reentrantLock1.m1()).start();
        new Thread(() -> reentrantLock1.m2()).start();
    }
}

package com.dingyu2;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
 * ReentrantLock对synchronized的扩展之tryLock()
 * 
 * @author dingyu
 *
 */
public class ReentrantLock2 {
    private Lock lock = new ReentrantLock();
    public void m1() {
        lock.lock();// 一直锁着，不手动释放， 和synchronized(this)类似，锁定的是堆的对象
    }
    public void m2() {
        boolean isNotLock = lock.tryLock();// 如果别的进程锁着就返回false，如果没锁返回true
        // 我们可以根据有没有锁来执行自己的逻辑，而不需要等着锁的释放，更加灵活
        if (isNotLock) {
            System.out.println("lock对象没有被锁定");
        } else {
            System.out.println("lock对象被锁定了");
        }
    }
    public static void main(String[] args) {
        ReentrantLock2 reentrantLock2 = new ReentrantLock2();
        new Thread(() -> reentrantLock2.m1()).start();
        new Thread(() -> reentrantLock2.m2()).start();
    }
}

package com.dingyu2;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
 * ReentranLock对synchronized的扩展：可以被另外的线程打断
 * 因为m1方法一直占着锁，m2永远不可能得到锁，既然得不到锁，我们就关闭m2好了，这时候得用lockInterruptibly
 * 
 * @author dingyu
 *
 */
public class ReentrantLock3 {
    private Lock lock = new ReentrantLock();
    public void m1() {
        lock.lock();
        try {
            System.out.println("t1 start");
            while (true) {
            }
        } finally {
            lock.unlock();
            System.out.println("t1 end");
        }
    }
    public void m2() {
        try {
            lock.lockInterruptibly();
            System.out.println("t2 start");
        } catch (InterruptedException e) {
            System.out.println("t2被打断了");
        } finally {
            if (lock.tryLock())
                lock.unlock();
            System.out.println("t2 end");
        }
    }
    public static void main(String[] args) {
        ReentrantLock3 reentrantLock3 = new ReentrantLock3();
        Thread t1 = new Thread(() -> reentrantLock3.m1(), "t1");
        t1.start();
        Thread t2 = new Thread(() -> reentrantLock3.m2(), "t2");
        t2.start();
        t2.interrupt();
    }
}

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
 * ReentrantLock对synchronized的扩展 ： 可以指定公平锁，哪个线程等待时间长，哪个先执行
 * 在构造函数中放入ture参数
 * 
 * @author dingyu
 *
 */
public class ReentrantLock4 {
    private Lock lock = new ReentrantLock(true);
    public void m1() {
        for (int i = 0; i < 10; i++) {
            try {
                lock.lock();
                System.out.println(Thread.currentThread().getName() + "running");
            } finally {
                lock.unlock();
            }
        }
    }
    
    public static void main(String[] args) {
        ReentrantLock4 lock4 = new ReentrantLock4();
        new Thread(()->lock4.m1(),"t1").start();
        new Thread(()->lock4.m1(),"t2").start();
    }
}

package com.dingyu2;
import java.util.LinkedList;
/**
 * 使用wait和notifyAll实现消费者生产者模式
 * 
 * @author dingyu
 *
 */
public class ProduceConsumer {
    private final LinkedList<Integer> lists = new LinkedList<Integer>();
    private final int MAX = 10;
    private int count = 0;
    public synchronized void put(Integer i) {
        while (lists.size() == MAX) { // wait大多数情况和while一起用
            try {
                this.wait();// 如果满了我就释放锁，并且等待
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        lists.add(i);// 生产一个
        count++;
        this.notifyAll();// 叫醒消费者可以消费啦
    }
    public synchronized Integer get() {
        while (lists.size() == 0) {
            try {
                this.wait();// 如果集合为空，不能消费，释放锁，等着
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        Integer num = lists.removeFirst();
        count--;
        this.notifyAll();// 叫醒生产者，可以继续生产啦
        return num;
    }
}

package com.dingyu2;
/**
 * 使用Condition 完成生产者消费者模式
 * @author dingyu
 *
 */
 
import java.util.LinkedList;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class ProduceConsumer2 {
    private final LinkedList<Integer> lists = new LinkedList<Integer>();
    private final int MAX = 10;
    private int count = 0;
    private Lock lock = new ReentrantLock();
    private Condition p = lock.newCondition();// 生产者
    private Condition c = lock.newCondition();// 消费者
 
    public void put(Integer i) {
        try {
            lock.lock();
            while (lists.size() == MAX) {
                try {
                    p.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            lists.add(i);
            count++;
            c.signalAll();
        } finally {
            lock.unlock();
        }
    }
    public Integer get() {
        Integer i = null;
        try {
            lock.lock();
            while (lists.size() == 0) {
                try {
                    c.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            i = lists.removeFirst();
            count++;
            p.signalAll();
        } finally {
            lock.unlock();
        }
        return i;
    }
}

package com.dingyu;
public class ThreadLocal1 {
    private ThreadLocal<Integer> tl = new ThreadLocal<Integer>();
    public void m1() {
        System.out.println(tl.get());
    }
    public void m2() {
        tl.set(7898);
    }
    public static void main(String[] args) {
        ThreadLocal1 local1 = new ThreadLocal1();
        new Thread(() -> local1.m2()).start();
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(() -> local1.m1()).start();
    }
}