1、什么时候会出现线程安全问题？
在多线程编程中，可能出现多个线程同时访问同一个资源，可以是：变量、对象、文件、数据库表等。此时就存在一个问题：
每个线程执行过程是不可控的，可能导致最终结果与实际期望结果不一致或者直接导致程序出错。
如我们在第一篇博客中出现的count--的问题。这是一个典型的非线程安全问题。这一被多个线程访问的资源count变量被称为：临界资源（共享资源）。但当多个线程执行一个方法，方法内部的局部变量并不是临界资源，因为方法在栈上执行，java栈是线程私有的，因此不会产生线程安全问题
2、如何解决线程安全问题？
基本上所有的并发模式解决线程安全问题，都采用序列化临界资源的方案，即同一时刻，只能有一个线程访问临界资源，也称作同步互斥访问。在访问临界资源的代码前加锁，当访问完临界资源后释放锁，让其他线程继续访问。java中提供了两种方式来实现同步互斥访问：synchronized和lock。
3、synchronized关键字详解
synchronized的三种应用方式包括：
a：修饰实例方法，作用于当前实例加锁，进入同步代码前要获得当前实例的锁
b：修饰静态方法，作用于当前类对象加锁，进入同步代码前要获得当前类对象的锁
c：修饰代码块，指定加锁对象，对给定对象加锁，进入同步代码库前要获得给定对象的锁
代码演示：实例对象锁就是synchronized修饰实例对象中的实例方法，实例方法不包括静态方法
public class ThreadDemo2 {
public static void main(String[] args) throws InterruptedException {
Test1 test1 = new Test1();
Thread t1 = new Thread(test1);
Thread t2 = new Thread(test1);
t1.start();
t2.start();
t1.join();
t2.join();
}
}
class Test1 implements Runnable{
//临界资源
static int i=0;
/**
* synchronized 修饰实例方法
*/
public synchronized void increase(){
i++;
}
@Override
public void run() {
for(int j=0;j<100000;j++){
increase();
System.out.println(i);
}
}
}
当synchronized修饰increase()方法后，i值的操作便是线程安全的。输出结果是200000，如果不加synchronized，结果可能小于这个值。当一个线程正在访问一个对象的synchronized实例方法，其他线程就不能访问该对象其他的synchronized方法。一个对象只有一把锁。当一个线程获取该对象的锁后，其他线程无法获取该对象的锁。但可以访问该对象的非synchronized方法。有一种特殊的情况，当两个线程访问的实例对象不同，则锁是不同的，当这两个线程操作数据并非共享的，线程安全是有保障的，但当操作数据是共享的，那么线程安全无法保证，演示 如下代码：
public class ThreadDemo2 {
public static void main(String[] args) throws InterruptedException {
Test1 test1 = new Test1();
Thread t1 = new Thread(test1);
Test1 test2 = new Test1();
Thread t2 = new Thread(test2);
t1.start();
t2.start();
t1.join();
t2.join();
}
}
class Test1 implements Runnable{
//临界资源
static int i=0;
/**
* synchronized 修饰实例方法 锁对象是实例对象
*/
public synchronized void increase(){
i++;
}
@Override
public void run() {
for(int j=0;j<100000;j++){
increase();
System.out.println(i);
}
}
}
此demo运行结果也会出现值小于20000，我们创建了两个Test1的实例，启动两个不同的线程对共享变量i进行操作，虽然我们队increase方法添加了同步锁，但却new了两个不同实例，此时就存在两个实例对象锁，因此t1和t2都会进入各自的对象锁，因此无法保证线程安全。解决这种错误地方式就是将synchronized作用于静态的increase方法，这样的话，对象锁就是当前类对象，无论创建多少个实例对象，类对象只有一个，对象锁是唯一的。
public class ThreadDemo2 {
public static void main(String[] args) throws InterruptedException {
Test1 test1 = new Test1();
Thread t1 = new Thread(test1);
Test1 test2 = new Test1();
Thread t2 = new Thread(test2);
t1.start();
t2.start();
t1.join();
t2.join();
}
}
class Test1 implements Runnable{
//临界资源
static int i=0;
/**
* synchronized 修饰静态方法，锁对象是类的class对象
*/
public static synchronized void increase(){
i++;
}
@Override
public void run() {
for(int j=0;j<100000;j++){
increase();
System.out.println(i);
}
}
}
synchronized作用于静态方法时，锁是当前类的class对象锁。静态成员是类成员。通过class对象锁可以控制静态成员的并发操作。需要注意的是：如果一个线程调用一个实例对象的非static synchronized方法，而另一个线程调用这个实例对象所属类的静态synchronized方法，是允许的，不会发生互斥现象。因为访问静态synchronized方法占用的锁是当前类的class对象，而非访问静态synchronized方法占用的当前实例对象锁。锁对象不同，但我们需要意识到这种情况下可能发生线程安全问题，因为操作了共享资源。
一些情况下，我们编写的方法体过大，同时存在一些比较耗时的操作。而需要同步的代码只有一小部分，我们可以通过synchronized代码块来对需要同步的代码进行包裹：
public class ThreadDemo2 implements Runnable{
static ThreadDemo2 test1 = new ThreadDemo2();
//临界资源
static int i=0;
@Override
public void run() {
//省略其他耗时操作....
//使用同步代码块对变量i进行同步操作,锁对象为test1
synchronized(test1){
for(int j=0;j<1000000;j++){
i++;
}
}
}
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(test1);
Thread t2 = new Thread(test1);
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println(i);
}
}
当前情况下，将synchronized作用于一个给定的实例对象test1，即当前实例对象就是锁对象，除了test1作为对象外，我们还可以使用this对象(synchronized(this)代表当前实例)或当前类的class对象作为锁(synchronized(ThreadDemo2.class))。
synchronized的一些特性：
在java中synchronized是基于原子性的内部锁机制，是可重入的，在一个线程调用synchronized方法的同时在其方法体内部调用该对象另一个synchronized方法，也就是说一个线程得到一个对象锁后再次请求该对象锁，是允许的，这就是synchronized的可重入性
线程中断与synchronized：对于synchronized来说，如果一个线程在等待锁，结果只有两种。要么它获得锁继续执行，要么保存等待，即使调用中断线程的方法，也不会有效。
等待唤醒机制与synchronized：这里主要指notify/notify/wait方法。使用这三个方法必须在synchronized代码块或synchronized方法中，否则就会抛出IllegalMonitorStateException异常。因为调用这几个方法必须拿到当前对象的monitor对象。monitor存在于引用指针中，而synchronized关键字可以获取monitor。与sleep不同的是wait方法调用完后，线程将被暂停，但wait方法会释放掉当前持有的锁。直到线程调用notify/notifyAll方法后才继续执行。sleep方法只让线程休眠并不释放锁。同时notify/notifyAll方法调用后，不会马上释放锁，而是在相应的synchronized代码块或synchronized方法执行结束后才自动释放锁。
synchronized实现原理：
synchronized同步块：
synchronized 同步语句块的实现使用的是 monitorenter 和 monitorexit 指令，其中 monitorenter 指令指向同步代码块的开始位置，monitorexit 指令则指明同步代码块的结束位置。 当执行 monitorenter 指令时，线程试图获取锁也就是获取 monitor(monitor对象存在于每个Java对象的对象头中，synchronized 锁便是通过这种方式获取锁的，也是为什么Java中任意对象可以作为锁的原因) 的持有权.当计数器为0则可以成功获取，获取后将锁计数器设为1也就是加1。相应的在执行 monitorexit 指令后，将锁计数器设为0，表明锁被释放。如果获取对象锁失败，那当前线程就要阻塞等待，直到锁被另外一个线程释放为止。
synchronized同步方法：
synchronized 修饰的方法并没有 monitorenter 指令和 monitorexit 指令，取得代之的确实是 ACC_SYNCHRONIZED 标识，该标识指明了该方法是一个同步方法，JVM 通过该 ACC_SYNCHRONIZED 访问标志来辨别一个方法是否声明为同步方法，从而执行相应的同步调用。
4、Lock详解
在上面synchronized的详解中，我们可以了解到当一个代码块被synchronized修饰，一个线程获取了对应的锁并执行该代码块。其他线程只能一直等待，等待获取锁的线程释放锁。这里获取锁的线程是释放锁的可能有两种：
1）获取锁的线程执行完该代码块，线程释放锁
2）线程执行发生异常，jvm会让线程自动释放锁
如果这个获取锁的线程由于等待IO或其他原因被阻塞且没有释放锁，其他线程便只能等待。这种情况下synchronized就有了一些缺陷。通过Lock我们可以弥补这些缺陷。
Lock的使用：
在lock接口中，有四个方法来获取锁。lock()、tryLock()、tryLock(long time,TimeUnit unit) 和lockInterruptibly()。使用unLock()来释放锁。由于lock不会主动释放锁，发生异常时，不会自动释放锁。一般使用Lock必须在try{}catch{}块中进行。并将释放锁的操作放在finally中，保证锁一定被释放，防止死锁的发生。
Lock()：获取锁，如果锁已被其他线程获取，则进行等待
Lock lock = ...;
lock.lock();
try{
//处理任务
}catch(Exception ex){ }finally{
//释放锁
lock.unlock();
}
tryLock()：尝试获取锁，如果获取成功，则返回true，如果获取失败则返回false。该方法无论如何都会立即返回，拿不到锁时不会一直等待。
tryLock(long time,TimeUnit unit)：与tryLock()方法类似，不同的是该方法拿不到锁时会等待一定时间，在时间期限内还拿不到锁就返回false。
Lock lock = ...;
if(lock.tryLock()){
try{
//处理任务
}catch(Exception ex){
}finally{
//释放锁
lock.unlock();
}
}else{
//如果不能获取锁，执行其他任务
}
lockInterruptibly()：获取锁时，如果线程正在等待获取锁，那该线程能响应中断，即中断等待状态。当两个线程同时通过lock.lockInterruptibly()想获取某个锁时，若A线程获取了锁，而B线程只能等待。那么对B线程调用threadB.interrupt()方法能够中断B线程的等待过程。该方法的声明中抛出了异常，使用时必须放在try块中或在调用方法外声明抛出InterruptedException。
public void method() throws InterruptedException {
lock.lockInterruptibly();
try {
//.....
}
finally {
lock.unlock();
}
}
注意：持有锁的线程，是不会被Interrupt()方法中断的，它只能中断阻塞过程中的线程。当通过lockInterruptibly()方法获取某个锁时，如果不能获取到，只有进行等待的情况下，才可以响应中断。
5、Lock接口的实现类ReentranLock
ReentrantLock是唯一实现了Lock接口的类，并提供了更多的方法。
Lock的正确使用
public class Test {
private ArrayList<Integer> arrayList = new ArrayList<Integer>();
//此处声明lock为全局变量
private Lock lock = new ReentrantLock();
public static void main(String[] args) {
final Test test = new Test();
new Thread() {
public void run() {
test.insert(Thread.currentThread());
};
}.start();
new Thread() {
public void run() {
test.insert(Thread.currentThread());
};
}.start();
}
public void insert(Thread thread) {
lock.lock();
try {
System.out.println("当前是线程:"+thread.getName()+"获得了锁");
for (int i = 0; i < 5; i++) {
arrayList.add(i);
}
} catch (Exception e) {
} finally {
System.out.println("线程:"+thread.getName()+"释放了锁");
lock.unlock();
}
}
}
此处注意，特意在声明Lock的时候注释了是全局变量。因为当lock在方法里创建成局部变量的时候。每个线程执行到lock.lock()获取到的是不同的锁。不会发生冲突。一般使用时将Lock声明为全局变量即可。
在这段代码里的insert()方法使用tryLock()方法，可以知道线程有没有获取到锁并输出结果。
public void insert(Thread thread) {
if(lock.tryLock()) {
try {
System.out.println("当前是线程:"+thread.getName()+"获得了锁");
for (int i = 0; i < 5; i++) {
arrayList.add(i);
}
} catch (Exception e) {
} finally {
System.out.println("线程:"+thread.getName()+"释放了锁");
lock.unlock();
}
}else {
System.out.println("线程:"+thread.getName()+"获取锁失败");
}
}
6、ReadWriteLock
ReadWriteLock定义了两个方法，一个用来获取读锁，一个用来获取写锁。将文件的读写操作分开，分成两个锁来分配给线程。使得多个线程可以同时进行读操作。
实现类：ReentrantReadWriteLock。主要两个方法readLock()和writeLock()用来获取读锁和写锁。
一个实例：多个线程同时进行读操作。使用synchronized
public class Test {
private ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
public static void main(String[] args) {
final Test test = new Test();
new Thread() {
public void run() {
test.get(Thread.currentThread());
};
}.start();;
new Thread() {
public void run() {
test.get(Thread.currentThread());
};
}.start();;
}
public synchronized void get(Thread thread) {
long start = System.currentTimeMillis();
while(System.currentTimeMillis() - start <= 1) {
System.out.println("线程:"+thread.getName()+"正在进行读操作");
}
System.out.println("线程:"+thread.getName()+"读操作完毕");
}
}
这样的输出结果可以发现，一个时间段内只有一个线程在执行读操作。一个线程执行完读操作，另一个线程才有机会执行。
改为读写锁，实现多个线程同时读操作
public void get(Thread thread) {
rwl.readLock().lock();
try {
long start = System.currentTimeMillis();
while(System.currentTimeMillis() - start <= 1) {
System.out.println("线程:"+thread.getName()+"正在进行读操作");
}
System.out.println("线程:"+thread.getName()+"读操作完毕");
} catch (Exception e) {
// TODO: handle exception
} finally {
rwl.readLock().unlock();
}
}
这段代码的输出结果可以看出，同时两个线程都在执行读操作。这样的话效率大大提升。不过要注意，如果一个线程占用了读锁，此时其他线程要申请写锁，那申请写锁的线程会一直等待释放读锁。如果一个线程占用了写锁，此时其他线程要申请写锁或读锁，则申请的线程会一直等待释放写锁。从性能上看，竞争资源不激烈，lock跟synchronized性能差不多，当竞争资源激烈时，lock的性能要远远优于synchronized。
Synchronized和lock区别：
1、Synchronized是java语言内置的特性，而lock是一个接口
2、Synchronized不需要用户手动释放锁，当synchronized方法或代码块执行完后，自动释放锁，而lock需要用户手动释放锁，如果没有手动释放，可能产生死锁
3、Synchronized修饰时，等待的线程会一直等待不能响应中断，lock可以让等待锁的线程响应中断。
4、Lock可以知道有没有成功获取锁（tryLock方法），而synchronized不可以
5、Lock可以提高多个线程进行读操作的效率
7、锁的概念：
可重入锁：从互斥锁的设计上来说，当一个线程试图操作一个由其他线程持有的对象锁的临界资源时，将会处于阻塞状态，但当一个线程再次请求自己持有对象锁的临界资源时，这种情况属于重入锁，请求将会成功。该分配机制是基于线程而非基于方法的调用。
class MyClass{
synchronized void method1(){
method2();
}
synchronized void method2(){
}
synchronized是可重入锁。当一个线程执行method1时，已经获取到了对象的锁。调用method2就无需重新申请锁。不具备重入性时，线程持有该对象的锁，又去申请该对象的锁。将会使线程一直等待永远获取不到锁。synchronized和Lock都具备可重入性。
可中断锁：可以响应中断的锁。即可以使在等待中的线程自己中断或者在别的线程中中断它。Lock是可响应中断的，synchronized不是。
公平锁：尽量以请求锁的顺序来获取锁。多个线程同时等待一个锁，当此锁被释放时，等待最久的线程优先获得该锁。
非公平锁：无法保证锁的获取是按照请求锁的顺序进行的。这样可能导致某个或一些线程永远获取不到锁，synchronized就是非公平锁，它无法保证等待的线程获取锁的顺序。对于ReentranLock和ReentrantReadWriteLock，它默认是公平锁，也可设置为非公平锁
读写锁：该锁将一个资源的访问分成了两个锁，读锁和写锁。保证了多个线程之间的读操作不发生冲突。ReadWriteLock是读写锁，它是一个接口。ReentrantReadWriteLock实现了这个接口。可以通过readLock()获取读锁，通过writeLock()获取写锁。