synchronized
锁是jvm控制的，控制锁住的代码块只能有一个线程进入。线程执行完了锁自动释放，抛出异常jvm会释放锁。
synchronized的缺陷
1.如果一个线程被阻塞了，其余的线程就要一直等下去，Lock可以在线程阻塞的时候其他线程不用一直等下去。
2.同时读文件时候，其他线程也要等待，lock可以做到读的时候不加锁，写的时候枷锁。
3.synchronized不知道线程有没有成功获取到锁。Lock可以知道线程有没有成功获取到锁。
package cn.itcast_01_mythread.thread.testThread;
public class MySynchronized {
// synchronized也可以放在方法上面
public static void main(String[] args) {
final MySynchronized mySynchronized = new MySynchronized();
final MySynchronized mySynchronized2 = new MySynchronized();
new Thread("thread1") {
public void run() {
synchronized (mySynchronized) {
try {
System.out.println(this.getName()+" start");
int i =1/0; //如果发生异常，jvm会将锁释放
Thread.sleep(5000);
System.out.println(this.getName()+"醒了");
System.out.println(this.getName()+" end");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}.start();
new Thread("thread2") {
public void run() {
synchronized (mySynchronized) { //争抢同一把锁时，线程1没释放之前，线程2只能等待
// synchronized (mySynchronized2) { //如果不是一把锁，可以看到两句话同时打印
System.out.println(this.getName()+" start");
System.out.println(this.getName()+" end");
}
}
}.start();
}
}
lock和synchronized的区别
1）synchronized是Java 内置特性，Lock不是。
2）synchronized不需要手动释放锁，代码块执行完或者抛出异常jvm会自动释放锁；Lock要手动释放锁，如果没有释放锁可能死锁。
java.util.concurrent.locks包下常用的类
首先要说明的就是Lock，通过查看Lock的源码可知，Lock是一个接口：
public interface Lock {
void lock();
void lockInterruptibly() throws InterruptedException;
boolean tryLock();
boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
void unlock();
}
Lock接口中每个方法的使用：
lock()、tryLock()、tryLock(long time, TimeUnit unit)、lockInterruptibly()是用来获取锁的。 unLock()方法是用来释放锁的。
四个获取锁方法的区别：
lock()方法是平常使用得最多的一个方法，就是用来获取锁。如果锁已被其他线程获取，则进行等待。
由于在前面讲到如果采用Lock，必须主动去释放锁，并且在发生异常时，不会自动释放锁。因此一般来说，使用Lock必须在try{}catch{}块中进行，并且将释放锁的操作放在finally块中进行，以保证锁一定被被释放，防止死锁的发生。
tryLock()方法是有返回值的，它表示用来尝试获取锁，如果获取成功，则返回true，如果获取失败（即锁已被其他线程获取），则返回false，也就说这个方法无论如何都会立即返回。在拿不到锁时不会一直在那等待。不等待。
tryLock(long time, TimeUnit unit)方法和tryLock()方法是类似的，尝试获取锁。只不过区别在于这个方法在拿不到锁时会等待一定的时间，在时间期限之内如果还拿不到锁，就返回false。如果如果一开始拿到锁或者在等待期间内拿到了锁，则返回true。异步过程，获取不到锁就去做别的，过一会再来获取锁。
lockInterruptibly()方法比较特殊，当通过这个方法去获取锁时，如果线程正在等待获取锁，则这个线程能够响应中断，即中断线程的等待状态。也就使说，当两个线程同时通过lock.lockInterruptibly()想获取某个锁时，假若此时线程A获取到了锁，而线程B只有等待，那么对线程B调用自己的threadB.interrupt()方法能够中断线程B的等待过程。等的人自己可以中断，不是获取到锁的人中断。synchronized时候等的人一直等待，不会跳出等待，一直等着。
当一个线程获取了锁之后，是不会被自己interrupt()方法中断的。
因此当通过lockInterruptibly()方法获取某个锁时，如果不能获取到，只有进行等待的情况下，是可以响应中断的。
package cn.itcast_01_mythread.thread.lock;
import java.util.ArrayList;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class MyLockTest {
private static ArrayList<Integer> arrayList = new ArrayList<Integer>();
static Lock lock = new ReentrantLock(); // 注意这个地方
public static <E> void main(String[] args) {
new Thread() {
public void run() {
Thread thread = Thread.currentThread();
lock.lock();//获取锁，用的是同一把锁
try {
System.out.println(thread.getName() + "得到了锁");
for (int i = 0; i < 5; i++) {
arrayList.add(i);
}
} catch (Exception e) {
// TODO: handle exception
} finally {
System.out.println(thread.getName() + "释放了锁");
lock.unlock();
}
};
}.start();
new Thread() {
public void run() {
Thread thread = Thread.currentThread();
lock.lock();//获取锁，用的是同一把锁
try {
System.out.println(thread.getName() + "得到了锁");
for (int i = 0; i < 5; i++) {
arrayList.add(i);
}
} catch (Exception e) {
// TODO: handle exception
} finally {
System.out.println(thread.getName() + "释放了锁");
lock.unlock();
}
};
}.start();
}
/*Thread-0得到了锁
Thread-0释放了锁
Thread-1得到了锁
Thread-1释放了锁*/
}
package cn.itcast_01_mythread.thread.lock;
import java.util.ArrayList;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* 尝试获取锁。观察现象：一个线程获得锁后，另一个线程取不到锁，不会一直等待
* @author
*
*/
public class MyTryLock {
private static ArrayList<Integer> arrayList = new ArrayList<Integer>();
static Lock lock = new ReentrantLock(); // 注意这个地方
public static void main(String[] args) {
new Thread() {
public void run() {
Thread thread = Thread.currentThread(); //run方法里面可以获取到当前线程
boolean tryLock = lock.tryLock();//尝试获取锁，如果其他线程已经获取到锁，这里就不获取了。
System.out.println(thread.getName()+" "+tryLock);
if (tryLock) {
try {
System.out.println(thread.getName() + "得到了锁");
for (int i = 0; i < 5; i++) {
arrayList.add(i);
}
} catch (Exception e) {
// TODO: handle exception
} finally {
System.out.println(thread.getName() + "释放了锁");
lock.unlock();
}
}
};
}.start();
new Thread() {
/* (non-Javadoc)
* @see java.lang.Thread#run()
*/
public void run() {
Thread thread = Thread.currentThread();
boolean tryLock = lock.tryLock();
System.out.println(thread.getName()+" "+tryLock);
if (tryLock) {
try {
System.out.println(thread.getName() + "得到了锁");
for (int i = 0; i < 5; i++) {
arrayList.add(i);
}
} catch (Exception e) {
// TODO: handle exception
} finally {
System.out.println(thread.getName() + "释放了锁");
lock.unlock();
}
}
};
}.start();
}
}
package cn.itcast_01_mythread.thread.lock;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* 可中断锁。观察现象：如果thread-0得到了锁，阻塞。。。thread-1尝试获取锁，如果拿不到，则可以被中断等待
* @author
*
*/
public class MyInterruptibly {
private Lock lock = new ReentrantLock();
public static void main(String[] args) {
MyInterruptibly test = new MyInterruptibly();
MyThread thread0 = new MyThread(test);
MyThread thread1 = new MyThread(test);
thread0.start();
thread1.start();
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
thread1.interrupt();//thread1拿到锁就不能中断了
System.out.println(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date())+"=====================");
}
public void insert(Thread thread) throws InterruptedException{
System.out.println(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date())+thread.getName()+"进来了");
//2个线程都调用lockInterruptibly获取锁，一个线程获取到锁后睡眠，另一个线程可以被中断。
//lockInterruptibly获取锁的方法，这个获取锁的方法是可以被中断的，中断的时候抛出InterruptedException异常。
lock.lockInterruptibly(); //注意，如果需要正确中断等待锁的线程，必须将获取锁放在外面，然后将InterruptedException抛出
try {
System.out.println(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date())+thread.getName()+"得到了锁");
long startTime = System.currentTimeMillis();
Thread.sleep(15000);
/*for( ; ;) {
if(System.currentTimeMillis() - startTime >= Integer.MAX_VALUE)//Integer.MAX_VALUE相当于阻塞
break;
//插入数据，
}*/
}
finally {
System.out.println(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date())+Thread.currentThread().getName()+"执行finally");
lock.unlock();
System.out.println(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date())+thread.getName()+"释放了锁");
}
}
}
class MyThread extends Thread {
private MyInterruptibly test = null;
public MyThread(MyInterruptibly test) {
this.test = test;
}
@Override
public void run() {
try {
test.insert(Thread.currentThread());//run方法里面可以获取到当前线程
} catch (Exception e) {
System.out.println(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date())+Thread.currentThread().getName()+"被中断");
}
}
}
/*2018-05-08 11:14:59Thread-0进来了
2018-05-08 11:14:59Thread-1进来了
2018-05-08 11:14:59Thread-0得到了锁
2018-05-08 11:15:01=====================
2018-05-08 11:15:01Thread-1被中断
2018-05-08 11:15:14Thread-0执行finally
2018-05-08 11:15:14Thread-0释放了锁*/
/*2018-05-08 11:19:06Thread-1进来了
2018-05-08 11:19:06Thread-0进来了
2018-05-08 11:19:06Thread-1得到了锁
2018-05-08 11:19:08=====================，Thread-1倍中断
2018-05-08 11:19:08Thread-1执行finally
2018-05-08 11:19:08Thread-1释放了锁
2018-05-08 11:19:08Thread-0得到了锁
2018-05-08 11:19:08Thread-1被中断
2018-05-08 11:19:23Thread-0执行finally
2018-05-08 11:19:23Thread-0释放了锁*/