线程本地锁

static关键字的四种用法
https://www.cnblogs.com/dotgua/p/6354151.html?utm_source=itdadao&utm_medium=referral

synchronized与static synchronized 的区别
https://www.cnblogs.com/shipengzhi/articles/2223100.html

synchronized(this)、synchronized(class)与synchronized(Object)的区别：
http://blog.csdn.net/luckey_zh/article/details/53815694

Java中的ReentrantLock和synchronized两种锁定机制的对比：
http://blog.csdn.net/fw0124/article/details/6672522
我们什么时候才应该使用 ReentrantLock 呢？答案非常简单 —— 在确实需要一些 synchronized 所没有的特性的时候，比如时间锁等候、可中断锁等候、无块结构锁、多个条件变量或者锁投票。ReentrantLock 还具有可伸缩性的好处。

Lock锁：简单粗暴

private Lock lock = new ReentrantLock();

加锁 lock.lock(); 十个线程拿锁，其中一个拿锁后，等待一个解锁，解锁后其他九个线程抢锁。
解锁 lock.unlock(); 解操作一定放在finally，当线程异常时，业务代码都会进行解锁操作。

package com.hailong.yu.dongnaoxuexi;

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

public class LockTest implements Runnable {

	private static int num = 0;
	// 倒计时器（发令枪），用于制造线程并发执行
	// 线程之间协同机制一种方式: lock、wait()和notify()、notifyAll()
	// 线程信号量机制: countDownLatch
	// 线程并发块：sychroznied
	// 事件（秒杀）：https://www.cnblogs.com/zsboy/p/3980894.html
	private static CountDownLatch countDownLatch = new CountDownLatch(10);
	
	// 静态锁，让线程用同一把锁
	private static Lock lock = new ReentrantLock();
	
	private String content;

	public String getContent() {
		return content;
	}

	public void setContent(String content) {
		this.content = content;
	}

	private LockTest(String content) {
		this.content = content;
	}
	
//	private Lock lock = new ReentrantLock();
	
	public void run() {
		try {
			// 线程运行等待（阻塞），等待发令枪为0;
			countDownLatch.await();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

		lock.lock();
		try {
//			counter.getAndIncrement();
			num++;
			// 同时并发访问打印方法
			System.out.println("线程：" + Thread.currentThread().getName()+" 打印文档: "+ num +content);
		} catch(Exception e) {
			e.getMessage();
		} finally {
			lock.unlock();
		}

		// 什么是线程安全问题 counter共享资源
		// 同一段代码在高并发情况下，每次运行结果都不一样。
		// 用锁的方式让其合理
	}

	public static void main(String[] args) {
		
		for(int i=0;i<10;i++) {
			// TODO Auto-generated method stub
			Thread thread = new Thread(new LockTest("天王盖地虎"));
			thread.setName("线程" + i);
			thread.start();
			// 排队处理线程，加了之后是同时处理线程
			countDownLatch.countDown();
		}
	}
}

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

/**
 * 
 */
public interface Lock {

    /**
     * 阻塞锁（synchonied是阻塞的）
     */
    void lock();

    /**
	 * 中断机制(可中断锁)
      * 可中断锁等候
     */
    void lockInterruptibly() throws InterruptedException;

    /**
     * 非阻塞式锁
     */
    boolean tryLock();

    /**
     * 
     */
    boolean tryLock(long time, TimeUnit unit) throws InterruptedException;

    /**
     * 解锁
     */
    void unlock();

    /**
     * 设置条件加锁或解锁
     * 多个条件变量
     */
    Condition newCondition();
}