JAVA -线程四(未完)

早上主要学习了Synchronized以及公平锁和非公平锁

1、所谓的Synchronized真正的含义叫做同步。同步的内容是一个对象，表示同一时刻，只会有一个线程对目标对象进行操作，而其他线程在执行前，会查看是不是有其他线程已经同步这个对象
2、 synchronize除了底层的同步对象以外，它实现在应用层面的时候，像极了排它锁，所以我们叫他锁真正意义上的java里面被叫做lock的东西，是有独立体系的。

线程的代码实现：
main：

public class Main {

	public static void main(String[] args) {
		ReentrantLock lock = new ReentrantLock();
		MyThread first = new MyThread(lock);
		SecondThread second = new SecondThread(lock);

		first.start();
		second.start();
		
		System.out.println(lock.getQueueLength());
		System.out.println(lock.hasQueuedThreads());
}
}
	

MyThread：

package com.ma1;

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

public class MyThread extends Thread {

//	Object mutex;
//	
//	public MyThread(Object mutea) {
//		this.mutex = mutex;
//	}

	ReentrantLock lock;

	public MyThread(ReentrantLock lock) {
		this.lock = lock;
	}

	@Override
	public void run() {
//		synchronized (mutex) {
//			
//		}

//		lock.lock();
//		for(int i = 0;i<100 ;i++) {
//			System.out.println(this.getName() + " : " + i);
//		}

		try {
			lock.lock();
//			if (lock.tryLock(1000, TimeUnit.MILLISECONDS)) {
//
//			} else {
//				System.out.println("锁失败");
//			}
			Thread.sleep(1000);
			for (int i = 0; i < 100; i++) {
				System.out.println(this.getName() + " : " + i);
			}
			System.out.println("hold count : " + lock.getHoldCount());
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally {
//			if (lock.isHeldByCurrentThread() && lock.isLocked()) {
//				c
//			}
			lock.unlock();
		}
		System.out.println("hold count : " + lock.getHoldCount());
	}

}

SecondThread：

package com.ma1;

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

public class SecondThread extends Thread {

	ReentrantLock lock;

	public SecondThread(ReentrantLock lock) {
		this.lock = lock;
	}

	@Override
	public void run() {
//		lock.lock();
//		for(int i = 0;i<100 ;i++) {
//			System.out.println(this.getName() + " : " + i);
//		}
//		lock.unlock();看看能否被锁住，返回一个布尔值

		try {
//			if(lock.tryLock(1000, TimeUnit.MILLISECONDS)) {
			//如果等待1000毫秒没有锁上的话，那么就解锁
//				for(int i = 0; i<100; i++) {
//					System.out.println(this.getName() + " : " + i);
//				}
//				//lock.unlock();
//			} else {
//				System.out.println("锁失败了");
//			}
			lock.lock();
			Thread.sleep(1000);
			for (int i = 0; i < 100; i++) {
				System.out.println(this.getName() + " : " + i);
			}
			System.out.println("Second : " + lock.getHoldCount());//看看被锁了几次
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if (lock.isHeldByCurrentThread() && lock.isLocked()) {
				lock.unlock();
			}
		}
	}
}

对比synchronize和ReentrantLock
二者都是可重入锁。都可以实现线程之间的同步过程
1、synchronize依赖底层对象的字节码实现，也就是说，其锁状态是加载了对象的字节码上了而ReentrantLock是依赖LockUtil.park();方法来实现加锁的过程。这个过程还用到了AQS所以其上层代码较多。只有在最后的阻塞过程，才使用了底层（C++）的部分实现
2、synchronize是可以在结束的时候许，主动释放掉资源的，但是Lock不行，必须手动调用unlock方法来释放资源
3、synchronize是可以手动在执行的过程中，通过wait方法短暂释放资源的，但是lock不行（因为lock底层没有对象的）

一些练习题：