线程安全以及解决

首先看一个线程不安全的例子

public class test {
    private static int count=0;
    public static void main(String[] args)throws InterruptedException {
        Thread t1=new Thread(()->{
            for (int i = 0; i < 5000; i++) {
               
                    count++;
            }
        });

        Thread t2=new Thread(()->{
            for (int i = 0; i < 5000; i++) {
                        count++；
            }
        });
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(count);

    }
}

上述代码创建了两个线程，分别对count变量进行自增5000次，按道理最后打印出来count的值应该是10000才是，可是实际上运行出来的结果小于10000，并且每次的运行结果还不一样。

造成上面线程不安全的原因涉及到以下几个方面：

首先操作系统对于线程调度是随机的，这是线程不安全的主要原因，另外在这个示例中，多个线程修改同一个变量，而对于这个变量的修改操作并不是原子的（也就是说不是不可分的），count++这个操作分为三步，首先需要load把数据从内存读取到寄存器中，然后add操作，最后save操作把寄存器的数据保存到内存中。那么由于线程调度的随机性，两个线程同时对一个变量进行修改，就会造成穿插，比如线程1在add时，下一步本来应该是线程1save，但是却穿插了线程2的操作，就会造成混乱，执行的排列结果有很多种，造成最后的结果也是不确定的。

为了解决这种问题，就需要进行加锁。用synchronized关键字进行加锁，就相当于把count的三步操作绑在一起。

synchronized修饰代码块，同时会指定一个锁对象，那么当两个线程同时对一个对象加锁的话，就会造成锁竞争，同一时间只能有一个线程拿到锁，那么另一个线程只能阻塞等待上一个线程释放锁

进入代码块就会进行加锁，出了代码块就解锁/释放锁。

 Object loker1=new Object();
        Thread t1=new Thread(()->{
            for (int i = 0; i < 5000; i++) {
                synchronized (loker1) {
                    count++;
                }
            }
        });

        Thread t2=new Thread(()->{
            for (int i = 0; i < 5000; i++) {
                    synchronized (loker1) {
                        count++；
                }
            }
        });

那么我们就可以定义一个锁对象。这时候两个线程对同一个锁对象加锁就会产生锁竞争，阻塞等待，运行结果就是10000。

synchronized不仅可以修饰代码块，还可以修饰一个实例方法或者静态方法。

class Counter {
	    public int count;
	
	    synchronized public void increase() {
	        count++;
	    }
	
	    public void increase2() {
	        synchronized (this) {
	            count++;
	        }
	    }
	
	    synchronized public static void increase3() {
	            count++:
	    }
	
	    public static void increase4() {
	        synchronized (Counter.class) {
	            count++;
	        }
	    }
	}

上述四种方法都是可以的。方法2用this作为锁对象。锁对象是什么不重要，重要的是要对同一个对象进行加锁，才能产生竞争。3，4修饰静态方法，4对类对象进行加锁。（Java中一个进程的类对象是唯一的）。

Synchronized的可重入性

可重入锁指的就是一个线程针对同一把锁加锁两次不会出现死锁。

对于以下代码

synchronized(loker){

synchronized(loker){
.....
}（2）

}

第一次加锁后，第二次尝试进行加锁，但此时loker已经被锁定了，只能等待锁被释放，但是最外层锁如果想被释放，要执行完代码，但是里面的代码又在阻塞等待锁，线程就会卡死，也就是死锁。

把synchronized设计为可重入锁就可以解决上述问题：让锁记录下是被哪个线程锁住的，下次这个线程再加锁的时候就可以成功加锁。上述代码在进行第二次加锁就可以成功了。

那么需要注意的是如果上述代码在第二次加锁成功后，执行完（2），是否应该释放锁？答案是不行。同样的如果加锁过程有n层，锁智能在执行完最外层代码才能被释放。因为如果提前释放锁，那么内层的一些代码受不到锁的保护，就有可能产生问题。

关于死锁

一个进程对于一把锁连续加锁两次，如果是不可重入锁，就会形成死锁。如果有两个线程t1,t2,两把锁loker1,loker2，t1获取loker1,t2获取loker2,如果这时候t1想获取loker2,t2想获取loker1，也会形成死锁。下面构建一个死锁代码：

Object loker1=new Object();
        Object loker2=new Object();

        Thread t1=new Thread(()->{
            synchronized (loker1){
                try {
                    Thread.sleep(1000);
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
                synchronized (loker2){
                    System.out.println("t1加锁成功");
                }
            }
        });
        Thread t2=new Thread(()->{
            synchronized (loker2){
                try {
                    Thread.sleep(1000);
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
                synchronized (loker1){
                    System.out.println("t2加锁成功");
                }
            }
        });
t1.start();
t2.start();

注意，sleep是必要的，要保证两个线程有时间都获得锁，否则可能t1一瞬间得到两把锁，t2没有锁。这时候代码是没有任何输出的，因为两个线程都没有得到第二把锁，线程卡死。

死锁的成因

四个必要条件

1互斥使用：是锁的基本特性，当一个线程持有一把锁，另一个线程也想获取锁，就要阻塞等待。

2不可抢占:锁的基本特性。当锁被一个线程获取之后，另一个线程只能等待锁被释放，不能强行占有。

3请求保持：一个线程尝试获取多把锁，先拿到一把锁后还想获取另一把锁，此时第一把锁不会被释放（吃着碗里的看着锅里的）。

4循环等待：等待形成环路关系，比如1等2，2等3，3等1.

只有同时满足上述四个条件才能形成死锁。所以如果要解决死锁问题，就要破坏上述条件。1，2是锁的特性，不可改变，就要从3和4下手。对于3，调整代码结构，避免写成锁的嵌套。对于4，可以约定加锁顺序，避免循环等待。