【java】Lock

package Synchronize;

/**
 JDK5新增加了Lock接口以及它的一个实现类ReentrantLock(重入锁)，Lock也可以用来实现多线程的同步。
 1.lock() 以阻塞的方式获取锁，也就说，如果获取到了锁就立刻返回，如果其他线程持有锁，当前线程等待，知道获取锁以后返回
 
 2.tryLock() 以非阻塞的方式获取锁。只是尝试性地去获取一下锁，如果获取到了锁，则立刻返回true，否则返回false
 
 3.tryLock(long timeout,TimeUnit unit) 如果获取了锁就立刻返回true，否则会等待参数给定的时间单元，在等待的过程中，如果获取到了锁就立刻返回，如果等待超时就返回false

 4.lockinterruptibly() 如果获取了锁，则立刻返回，如果没有获取锁，则当前线程处于休眠的状态 知道获取了锁或者是当前线程被其他线程中断(会有InterruptedException)
 它与lock()方法最大的区别在于：如果lock方法获取不到锁，则会一直处于阻塞的状态，且会忽略interrupt()方法。
 
 * */

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

public class LockTest {
    public static void main(String[] args) throws InterruptedException {
        final Lock lock=new ReentrantLock();
        lock.lock();
        Thread thread=new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    lock.lockInterruptibly();
                   // lock.lock();//编译报错 不需要ccatch 证明了lock()方法是会忽略interrupt()引发的异常的
                }catch (InterruptedException e){
                    System.out.println("interrupted");
                    e.printStackTrace();
                }
            }
        });
        thread.start();
        thread.interrupt();
        Thread.sleep(1);
    }
}

package Synchronize;

//https://examples.javacodegeeks.com/core-java/util/concurrent/locks-concurrent/reentrantlock/java-reentrantlock-example/

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;


public class ThreadSafeArrayList<E>
{
    private final Lock lock = new ReentrantLock();

    private final List<E> list = new ArrayList<E>();

    private static int i = 0;

    public void set(E o)
    {
        lock.lock();

        try
        {
            i++;
            list.add(o);
            System.out.println("Adding element by thread"+Thread.currentThread().getName());
        }
        finally
        {
            lock.unlock();
        }
    }

    public static void main(String[] args)
    {

        final ThreadSafeArrayList<String> lockExample = new ThreadSafeArrayList<String>();
        Runnable syncThread = new Runnable()
        {

            @Override
            public void run()
            {
                while (i < 6)
                {
                    lockExample.set(String.valueOf(i));

                    try
                    {
                        Thread.sleep(100);
                    }
                    catch (InterruptedException e)
                    {
                        e.printStackTrace();
                    }
                }
            }
        };
        Runnable lockingThread = new Runnable()
        {

            @Override
            public void run()
            {
                while (i < 6)
                {
                    lockExample.set(String.valueOf(i));
                    try
                    {
                        Thread.sleep(100);
                    }
                    catch (InterruptedException e)
                    {
                        e.printStackTrace();
                    }
                }
            }
        };
        Thread t1 = new Thread(syncThread, "syncThread");
        Thread t2 = new Thread(lockingThread, "lockingThread");
        t1.start();
        t2.start();
    }
}

/*
Adding element by threadsyncThread
Adding element by threadlockingThread
Adding element by threadsyncThread
Adding element by threadlockingThread
Adding element by threadlockingThread
Adding element by threadsyncThread
* */