13_线程安全

【线程安全概念】

当多个线程访问某一个类（或对象、方法）时，这个类始终都能表现出正确的行为，那么这个类就是线程安全的。

【synchronized】

可以在任意对象及方法上加锁，而加锁的这段代码被称为“互斥区”或“临界区”。

【不加synchronized和加synchronized的不同情况】

package com.higgin.part1;

public class MyThread extends Thread{
    
    private int count=5;
    
    @Override
    public void run(){   //分别synchronized加锁和不加锁运行
        count--;
        System.out.println(this.currentThread().getName() + "， count="+count);
    }
    
    
    public static void main(String[] args) {
        /**
         * 分析：
         * 当多个线程访问myThread的run方法时，以排队的方式进行处理（这里的排队是指CPU分配的先后顺序而定的），
         * 一个线程想要执行synchronized修饰的方法里的代码：
         *     1.尝试获得锁
         *     2.如果拿到锁，执行synchronized代码 体的内容；拿不到锁，这个线程机会不断的尝试获得这把锁，直到拿到为止（这里有多个线程竞争这把锁）
         * 
         */
        MyThread mt = new MyThread();
        Thread t1 = new Thread(mt,"t1");
        Thread t2 = new Thread(mt,"t2");
        Thread t3 = new Thread(mt,"t3");
        Thread t4 = new Thread(mt,"t4");
        Thread t5 = new Thread(mt,"t5");
        
        t1.start();
        t2.start();
        t3.start();
        t4.start();
        t5.start();
    }
}

【运行结果：不加synchronized锁（结果无法确定）】

【运行结果：加synchronized锁】

【多个线程多个锁的情况（区别对象锁和类锁）】

package com.higgin.part2;

public class MyThread {
    private static int num=0;
    
    /**
     * 分别用加static和不加static来运行
     * 不加static : 对象锁
     * 加上static : 类锁
     */
    public synchronized void printNum(String tag){
        try {
            if(tag.equals("a")){
                num=100;
                System.out.println("tag='a',set num OK !");
                Thread.sleep(1000);
            }else if(tag.equals("b")){
                num=200;
                System.out.println("tag='b',set num OK !");
            }
            System.out.println("【finally】tag = "+tag +", num = "+num);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    
    public static void main(String[] args) {
        //创建两个不同的对象
        final MyThread m1 = new MyThread();
        final MyThread m2 = new MyThread();
        
        Thread t1= new Thread(new Runnable() {
            @Override
            public void run() {
                m1.printNum("a");
            }
        });
        
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                m2.printNum("b");
            }
        });
        
        t1.start();  //如果线程安全，必须得等t1执行完run方法，释放锁之后，t2才能获得锁执行run方法
        t2.start();
    }
}

【运行结果：不加static，非静态方法，为对象锁，可以看到t1和t2两个线程时并发执行的】

【运行结果：加上static，静态方法，为类锁，t1和t2同步执行】

【对象的同步和异步】

同步：synchronized

　　同步的概念就是共享，要牢记“共享”两个字，如果不是共享的资源，没有必要同步。

异步：asynchronized

　　异步的概念就是独立，相互之间不受到任何制约。比如http请求中，在页面发起Ajax请求时，我们依然可以继续浏览或者操作页面内容，二者之间没有任何关系。

[ 线程安全的特性 ]

同步的目的就是为了线程安全，线程安全的两个特性：原子性（同步）、可见性。

package com.higgin.part3;

/**
 * 对象锁的同步和异步问题
 */
public class MyObject {
    private int num=0;
    
    public synchronized void setNum(int num){
        try {
            Thread.sleep(4000);
            this.num= num;
            System.out.println(Thread.currentThread().getName()+",set num = "+this.num);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    
    /**
     * 针对的是同一个对象的对象锁
     * 加上synchronized :当一个线程已经在执行setNum()方法的时候，另一个线程无法访问readNum方法
     * 不加synchronized :当一个线程已经在执行setNum()方法的时候，另一个线程可以访问readNum方法
     */
    public void readNum(){
        System.out.println(Thread.currentThread().getName()+", get Num = "+this.num);
    }
    
    
    public static void main(String[] args) {
        final MyObject mo = new MyObject();  //注意是一个对象！如果是两个对象，本身的锁已经不同
        
        /**
         * t1线程先持有对象的锁，t2线程可以异步的方式调用对象中的非synchronized修饰的方法
         * t1线程先持有对象的锁，t2线程如果在这个时候调用对象中的同步（synchronized）方法，则需等待t1释放锁，也就是同步执行
         */
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                mo.setNum(100);
            }
        },"t1"); 
        
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                mo.readNum();
            }
        },"t2");
        
        t1.start();
        t2.start();
    }
    
}

【运行结果：readNum()不加synchrobized锁，t1持有setNum方法的锁，但t2不会去等待t1释放锁，直接去执行readNum方法】

【运行结果：readNum()加上synchronized锁，t1持有setNum方法的锁，t2必须等待t1释放锁才能获得readNum方法的锁】

【分析】

上面这个例子即一个“脏读”的例子。

对一个对象的方法加锁时，需要考虑业务的完整性，即为setValue()/getValue()方法同时加锁synchronized关键字，保证业务的完整性。

【问：当一个线程进入一个对象的synchronized的方法时，其他线程是否可以进入此对象的其他方法？】

答：

1.如果是创建的不同对象（如myObj1、myObj2对象），那么两个对象执行各自的方法不会相互影响，为异步的。

2.如果是同一个对象（只有一个myObj对象），如果一个线程进入一个对象的synchronized修饰的方法，如果其他的那个方法是非sychronized方法，那么是可以访问的。

3.如果是同一个对象（只有一个myObj对象），如果一个线程进入一个对象的synchronized修饰的方法，如果其他的那个方法是sychronized方法，那么是不可以访问的。