Java线程安全问题

1. 自增运算不是安全的

package threadpool;

public class PlusTest {
    private static int count=0;
    static void increse()
    {
        count++;
    }
    public static void main(String[] args) throws InterruptedException {
        Runnable task=new Runnable() {

            @Override
            public void run() {
               for(int i=0;i<1000;i++)//每个线程执行10次自增操作
                     increse();
                
            }
            
        };
        for(int i=0;i<10;i++)//创建10个线程
            new Thread(task).start();;

        Thread.sleep(3000);//等待线程执行完成
        System.out.println("预期结果："+10000);
        System.out.println("实际结果："+count);
    }
}

上面的代码创建了10个线程，每个线程进行1000次自增操作，理论上结果应该是10000，但是实际结果小于10000，运行两次结果如下：

原因分析：
一个自增运算符是一个复合操作，至少包括三个JVM指令：“内存取值”“寄存器增加1”和“存值到内存”。这三个指令在JVM内部是独立进行的，中间完全可能会出现多个线程并发进
假设当count=1时右3个线程同时内存取值，得到count的值为1，然后各自进行自增操作后再将值放入内存，结果是count=2而不是4

---

2. 临界资源与临界区代码

临界区资源表示一种可以被多个线程使用的公共资源或共享数据，但是每一次只能有一个线程使用它。一旦临界区资源被占用，想使用该资源的其他线程则必须等待
临界区资源是受保护的对象。临界区代码段（Critical Section）是每个线程中访问临界资源的那段代码

在上面的自增代码例子中，count是临界资源，执行count++的代码是临界区代码

---

3. synchronized同步方法

使用synchronized关键字修饰一个方法的时候，该方法被声明为同步方法

修改上面的自增代码如下：

package threadpool;

public class PlusTest {
    private static int count=0;
    static synchronized void increse()
    {
        count++;
    }
    public static void main(String[] args) throws InterruptedException {
        Runnable task=new Runnable() {

            @Override
            public void run() {
               for(int i=0;i<1000;i++)//每个线程执行10次自增操作
                     increse();
                
            }
            
        };
        for(int i=0;i<10;i++)//创建10个线程
            new Thread(task).start();;

        Thread.sleep(3000);//等待线程执行完成
        System.out.println("预期结果："+10000);
        System.out.println("实际结果："+count);
    }
}

执行3次的结果如下：

synchronized同步关键字，保证其方法的代码执行流程是排他性的。任何时间只允许一个线程进入同步方法（临界区代码段），如果其他线程需要执行同一个方法，那么只能等待和排队

---

4. synchronized同步块

使用synchronized修饰方法使得整个方法只能同时由1个线程访问，但是当方法内的代码较大时，会降低执行效率，比如方法中进行好几个count的自增操作，当前某个线程完成了对count1的自增操作后，其他线程依然不能访问count1

package threadpool;

public class PlusTest {
    private static int count1=0;
    private static int count2=0;
    private static Integer lock1=new Integer(1);//同步锁1
    private static Integer lock2=new Integer(2);//同步锁2
    static void increse()
    {
        synchronized(lock1)
        {
            count1++;
        }
        synchronized(lock2)
        {
            count2++;
        }
       
       
    }
    public static void main(String[] args) throws InterruptedException {
        Runnable task=new Runnable() {

            @Override
            public void run() {
               for(int i=0;i<1000;i++)//每个线程执行10次自增操作
                     increse();
                
            }
            
        };
        long start=System.currentTimeMillis();
        for(int i=0;i<10;i++)//创建10个线程
            new Thread(task).start();;

        Thread.sleep(3000);//等待线程执行完成
        System.out.println("count1预期结果："+10000);
        System.out.println("count1实际结果："+count1);
        System.out.println("count2预期结果："+10000);
        System.out.println("count2实际结果："+count2);
    }
}

synchronized方法和方法块的区别和联系：

1. synchronized方法是一种粗粒度的并发控制，某一时刻只能有一个线程执行该synchronized方法
2. synchronized代码块是一种细粒度的并发控制，处于synchronized块之外的其他代码是可以被多个线程并发访问的
3. 一个方法中，并不一定所有代码都是临界区代码段，可能只有几行代码会涉及线程同步问题
4. synchronized方法实际上等同于用一个synchronized代码块，这个代码块包含同步方法中的所有语句
5. synchronized方法的同步锁实质上使用了this对象锁
6. synchronized关键字修饰static方法时，同步锁为类锁；当synchronized关键字修饰普通的成员方法（非静态方法）时，同步锁为对象锁

---

参考书籍：参考书籍：《Java高并发编程卷2》 尼恩