synchronized与lock

浅聊一下synchronized和lock

关于synchronized 我个人理解的观点来看，最多可以细分为5种方式。分为两类。其中类锁2种，对象锁3种。

• 下方代码中定义了5种方法，test1和test2方法为类锁，test3、test4、test5方法为对象锁。

• 让我们执行一下main方法，会发现类锁方法和对象锁方法是交替执行的，因为同类的锁方法执行时是互斥的、 非同类的锁是不互斥的。执行test1时，因为test1拿到了类锁，test2执行时会被阻塞，等待test1释放类锁。对象锁同理。

• 注意：对象锁方法互斥的前提是锁的对象得是同一个。

public class Test {
    private static final Test test = new Test();

    public static void main(String[] args) {
        
        new Thread(() -> {
            test.test1();
        }).start();
        new Thread(() -> {
            test.test2();
        }).start();
        new Thread(() -> {
            test.test3();
        }).start();
        new Thread(() -> {
            test.test4();
        }).start();
        new Thread(() -> {
            test.test5();
        }).start();
    }
    //类锁
    public static synchronized void test1(){
        System.out.println("test1...");
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    //类锁
    public void test2(){
        synchronized (Test.class){
            System.out.println("test2...");
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
	//对象锁
    public void test3(){
        synchronized (test){
            System.out.println("test3....");
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    //对象锁
    public void test4(){
        synchronized (this){
            System.out.println("test4....");
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    //对象锁
    public synchronized void test5(){
        System.out.println("test5....");
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

lock：使用lock加锁而不释放锁，可以重复获取，例如下方代码，可以输出111和222。不释放锁时，锁一直会被当前线程持有。

public static void main(String[] args) {
		for (int i = 0; i < 10; i++) {
			new Thread(() -> {
				try {
					lock.lock();
					Thread.sleep(1000);
					System.out.println("11111111111111111111");
					lock.lock();
					Thread.sleep(1000);
					System.out.println("2222222222222222222");
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}).start();
		}

上面我们说到，使用lock加锁后但不释放锁会被当前线程一直持有，怎么证明呢？来吧，直接上代码。

private static ThreadPoolExecutor threadPool = new ThreadPoolExecutor(5,
			5,
			1,
			TimeUnit.SECONDS,
			queue,
			new ThreadPoolExecutor.DiscardPolicy());

public void test1(){
		final ReentrantLock takeLock = this.takeLock;
		for (int i = 0; i < 10; i++) {
			threadPool.execute(() -> {
				try {
					System.out.println("开始Thread.currentThread().getName() = " + Thread.currentThread().getName());
					takeLock.lock();
					Thread.sleep(2000);
					System.out.println("结束Thread.currentThread().getName() = "+Thread.currentThread().getName());
				} catch (InterruptedException e) {
					e.printStackTrace();
				}finally {
					//takeLock.unlock();
				}
			});
	 }
}

• 上面我们定义一个线程池，核心线程数5个，保证线程能复用。另外将takeLock.unlock();注释掉了不对所进行释放，下面为输出结果,可以看见，线程1获取到锁后一直没有释放，其他4个核心线程无法获取到锁一直阻塞，所以执行任务的一直是线程1，因为不释放锁时会一直持有该锁。

贴一章关于锁的竞争与释放的代码，大家在不执行代码的情况下，说一下执行顺序，结果你猜对了吗？

public static void main(String[] args) {
		new Thread(() ->{
			synchronized (resourceA){
				System.out.println("111111111111111111");
				try {
					Thread.sleep(3000);
					resourceA.wait();
					System.out.println("22222222222222222222222");
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}).start();
		new Thread(() ->{
			synchronized (resourceA){
				System.out.println("333333333333333333333333333");
				new Thread(() ->{
					synchronized (resourceA){
						System.out.println("4444444444444444444444444");
						while(true){

						}
					}
				}).start();
				resourceA.notify();
				System.out.println("5555555555555555555555");
			}
		}).start();
	}

聊一下个人对上述代码的理解。

• 开启一个线程1，获取锁打印111，睡眠3秒后，wait线程挂起并释放锁。

• 开启一个线程2，当前成功获取到锁打印333，内部开启新的线程，但此时内部线程里也加了代码块，并且锁的资源都为resourceA，因为锁为同一资源的代码块会互斥,此时内部开启的线程进入阻塞状态，等待获取锁。

• 在线程2中执行 notify() 方法，唤醒线程1，但该操作不会立刻让线程1执行后续代码，而是线程2里的代码执行完毕后才会醒来执行线程1的后续代码。因此先输出555，线程2里的代码执行完毕释放锁。

• 线程1醒来，会重新拿到锁，并执行后续的代码输出222，结束后释放锁。

• 内部线程获取到锁，执行444

• 最终的输出为 111 - > 333 -> 555 -> 222 -> 444。

• 其中我有个小小的疑点，就是在线程2执行完毕后，为什么不是内部线程先获取到锁输出444，而是输出线程1的222。可能是因为被wait的线程1有优先获取锁的优先级把。