Lock之ReentrantLock

package com.yang.spbo.other.lock;

import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

/**
 * A,B两个线程交替执行
 * 〈功能详细描述〉
 *
 * @author 17090889
 * @see [相关类/方法]（可选）
 * @since [产品/模块版本] （可选）
 */
public class ConditionService {
    private ReentrantLock lock = new ReentrantLock();
    /**
     * 两个线程所以创建两个condition
     */
    private Condition A = lock.newCondition();
    private Condition B = lock.newCondition();

    private int number = 1;

    private boolean flag = false;

    private void executeA() {
        while (number < 100) {
            try {
                lock.lock();
                if (!flag) {
                    System.out.println("A等待");
                    A.await();
                }
                System.out.println("A " + number);
                number++;
                flag = false;
                System.out.println("B唤醒");
                B.signal();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }

    }

    private void executeB() {
        while (number < 100) {
            try {
                lock.lock();
                if (flag) {
                    System.out.println("B等待");
                    B.await();
                }
                System.out.println("B " + number);
                number++;
                flag = true;
                System.out.println("A唤醒");
                A.signal();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }

    }

    public static void main(String[] args) {
        final ConditionService cs = new ConditionService();
        ThreadPoolExecutor executor = new ThreadPoolExecutor(2, 5, 1, TimeUnit.MINUTES, new LinkedBlockingDeque<Runnable>(1000), new MyThreadFactory("conditionService"));

        executor.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
                cs.executeA();
            }
        });
        executor.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
                cs.executeB();
            }
        });
    }

    static class MyThreadFactory implements ThreadFactory {
        /**
         * 线程名字前缀
         */
        private String namePrefix;

        private AtomicInteger id = new AtomicInteger(1);

        public MyThreadFactory(String namePrefix) {
            this.namePrefix = namePrefix;
        }

        @Override
        public Thread newThread(Runnable r) {
            String threadName = namePrefix + "-worker-" + id.getAndIncrement();
            Thread thread;
            thread = new Thread(r, threadName);
            return thread;
        }
    }
}

/**
* ReentrantLock实现死锁
* 〈功能详细描述〉
*
* @author 17090889
* @see [相关类/方法]（可选）
* @since [产品/模块版本] （可选）
*/
public class DeadLockTest {
    private static ReentrantLock lock1 = new ReentrantLock();
    private static ReentrantLock lock2 = new ReentrantLock();

    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                lock1.lock();
                try {
                    Thread.sleep(1000);
                    lock2.lock();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lock1.unlock();
                }
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                lock2.lock();
                try {
                    Thread.sleep(1000);
                    lock1.lock();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lock2.unlock();
                }

            }
        }).start();
    }
}

/**
* synchronized实现死锁
* 〈功能详细描述〉
*
* @author 17090889
* @see [相关类/方法]（可选）
* @since [产品/模块版本] （可选）
*/
public class DeadLockTest2 {
    private static Object obj1 = new Object();
    private static Object obj2 = new Object();

    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (obj1) {
                    System.out.println("thead1 get lock1");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (obj2) {
                        System.out.println("thead1 get lock2");
                    }
                    System.out.println("thread1 end");
                }
            }
        }, "thead1").start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (obj2) {
                    System.out.println("thead2 get lock2");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (obj1) {
                        System.out.println("thead2 get lock1");
                    }
                    System.out.println("thread2 end");
                }
            }
        }, "thead2").start();
    }
}