JAVA 多线程（3）

再讲线程安全：

一、脏读

脏读：在于读字，意在在读取实例变量时，实例变量有可能被另外一个线程更改了，导致获取到的数据出现异常。

在非线程安全的情况下，如果线程A与线程B 共同使用对象实例C中的方法method，如果实例C存在实例变量，同时在method中会操作这个实例变量a，则有可能出现脏读的情况。

也就是期望值不同，读取的数据不同，因为线程A与B会同时使用实例C的方法。

例如：

private String name;

    public static void main(String[] args){
        Test2 test2 = new Test2();
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
//                System.out.println(Thread.currentThread().getName());
                test2.testUnsafe("a","我是A");
            }
        });

        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
//                System.out.println(Thread.currentThread().getName());
                test2.testUnsafe("b","我是B");
            }
        });

        t.start();
        t2.start();
    }

    public void testUnsafe(String name,String param){
        this.name = name;
        try {
    　　　　　　Thread.sleep(1000);
    　　　　　　System.out.println(this.name+":"+param);
　　　　} catch (InterruptedException e) {
    　　　　　　e.printStackTrace();
　　　　}
    }

执行结果如下：

代码中加上了sleep 为了模拟运算所需的时间。

可以看出来，大概是这样的过程：线程B在run时首先抢到了资源，并运行了实例方法，并把实例变量name修改为b，

然后继续执行，这时候线程A抢回了资源（因为不是同步的），它把实例变量那么又修改为b，这个是时候开始执行其他逻辑操作（这里用sleep模拟），

然后2个线程轮番执行最后的操作-打印。

因为这个时候实例变量name 已经变为a了， 所以线程B 出现脏读，和期望输出的  b:我是B  结果出现差异。

如果操作的是不同的对象实例（在synchronized 同步里 jvm 会创建多个锁，下面的例子控制2个实例，也就是创建了2个锁），就不会出现这个问题了，还有如果name不是实例变量，只是私有变量的话也不会出现这种情况。

修改一下看看：

 public static void main(String[] args){

        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                Test2 test2 = new Test2();
                test2.testUnsafe("a","我是A");
            }
        });

        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                Test2 test2 = new Test2();
                test2.testUnsafe("b","我是B");
            }
        });

        t.start();
        t2.start();
    }

输出结果：

如果想要保证使用实例变量而又不出现这种问题，怎么办，同步~ 可以使用 synchronized 方法或 synchronized代码块。

例如：

public synchronized void testUnsafe(String name,String param){
        this.name = name;
        try {
            Thread.sleep(1000);
            System.out.println(this.name+":"+param);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }

输出结果：

关于synchronized 想看的可以下看之前的随笔（《JAVA 多线程（1）》）。

这里我想记录一下类与对象和实例的个人理解（）：

Class 是类，编写时候我们称为类，编译好的class我们可以称为class对象，或者说类对象，由类对象new出来的是实例或者说叫对象实例也就是instance。

它们分时期，分关系。类是抽象的概念，对象为具体的事物，人是类，张三是人，张三是人这个类具象，是一个对象实例的存在，它的嘴巴是实例变量，吃饭是实例方法，米饭和菜是吃饭这个对象方法中的方法私有变量，

打比方张三、李四在一起去吃饭（2个线程），都调用了吃饭这个方法（吃饭这个方法是人类共有的），分布是土豆A与土豆B，如果不做同步，有可能2个人会夹到同一条土豆丝。

好吧，上面的比方看看就好。

二、可重入锁

如果一个线程获取了或者说抢到了cpu资源，拿到了实例对象锁，那么在实例方法中在调用其他同步方法时，依然会获取到同一个锁，因为已经抢到了，

比方说，一个屋子有3个房间（方法），张三（线程），抢到了房间1的锁，由于李四和王五压根就没进入这个屋子，所有他们俩必须等张三出来才行，这样的话

张三进过房间1后，还能获得房间2、3的锁。

这个锁指的是对象锁，或者说一个实例对象只有一把锁会更好理解。因为李四和王五想进房间2，虽然不是房间1，但是只有一把锁，这个锁在张三手上。

可重入锁个人感觉主要贡献在于可继承，如果B基础了A，那么如果操作B，获取到了实例对象B的锁，那么也可以继续获得A的锁。

三、异常释放锁

当线程出现异常时，锁会自动释放。

四、同步不具有继承

如果类A 有同步方法 methodA，类B继承了类A并重写了methodA 方法，但是没有加上同步关键字，那么实际上，B类中重写的methodA 并不是同步方法。

五、同步方法与同步代码块

之前在1中写过，这里再提及，同步代码块同样时获得的是对象锁，当不同的实例方法各自有各自的同步代码块，当线程A访问methodA 时获得实例对象锁，如果线程B访问的实例对象与线程A相同，那么线程B如想

访问methodB中的同步代码块时同样需要等线程A使用完methodA，释放对象锁，才能执行。

六、非当前实例对象锁（任意对象监视器）

优点：同一个类中的多个方法或者同一个方法中有多个代码块，为了提高性能，使用多个对象锁，来加快运行速度，或者说减少阻塞。

例如：

private Object object = new Object();

public static void main(String[] args){
    Test2 test2 = new Test2();
    Thread t = new Thread(new Runnable() {
        @Override
        public void run() {
            test2.test();
        }
    });

    Thread t2 = new Thread(new Runnable() {
        @Override
        public void run() {
            test2.test2();
        }
    });

    t.start();
    t2.start();
}
public void test2(){
    synchronized (object){
        System.out.println("我是第二个块"+Thread.currentThread().getName());
    }
}

public void test(){
    synchronized (this){
        try {
            System.out.println("我是第一个块 开始:"+Thread.currentThread().getName());
            Thread.sleep(100);
            System.out.println("我是第一个块 结束:"+Thread.currentThread().getName());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

输出：

通过控制台打印结果可以看出，在A线程访问test方法执行的同时，B线程同样访问可test2方法。

所以，他们互不干扰，因为不是一把锁。

但是问题又出来，就因为这样提高了性能，但是又有可能会导致脏读，如果methodA与methodB 中有对同一个实例变量的写操作，那么及有可能出现脏读。

如下：

private Object object = new Object();
    private static List<String> list = new ArrayList<>();
    public static void main(String[] args){
        Test2 test2 = new Test2();
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                test2.test();
            }
        });

        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                test2.test2();
            }
        });

        t.start();
        t2.start();
        try {
            Thread.sleep();
            System.out.println(list.size());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    public void test2(){
        synchronized (object){
            judge("test2");
        }
    }

    public void test(){
        synchronized (this){
            judge("test");

        }
    }

    public void judge(String what){
        try {
            if(list.size() < 1){
                Thread.sleep(2000);
                list.add(what);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

输出结果：

出现了，以为是异步的，所以线程A和线程B都可以同时访问到judge方法，又同时进入到了if语句中，导致最终结果输出为2，而不是我们期望的1。

所以，方法就是，给judge加上同步锁：

synchronized (list){
                if(list.size() < 1){
                    Thread.sleep(2000);
                    list.add(what);
                }
            }

这样拿到list对象锁的操作就变成同步的了~

明儿个继续~