美文网首页Java 杂谈Java
Java 线程安全及非线程安全

Java 线程安全及非线程安全

作者: 凯恩_Kane | 来源:发表于2019-02-08 22:38 被阅读0次

    类中一般会出现三种数据:

    • 静态成员变量
    • 普通成员变量
    • 方法里定义的局部变量(包括方法参数变量)。
      对于第三种变量,不管是静态方法还是动态方法,都不会存在线程安全问题。原因是:
      方法在执行的时候,方法里的局部变量都是存储在堆栈上的。而方法的堆栈分配,是在方法每次执行开始时系统分配的,所以即使是调用同一方法(不管是不是同一线程),所分配的堆栈也是不同的。

    对于第二种变量,同一个类的不同的对象实例有不同的成员变量,所以多个线程如果可以确定是在操作不同的对象,就不会存在冲突。如果多个线程操作的是同一个对象实例,则需要考虑对类内普通成员变量操作的线程安全问题。

    对于第一种变量,因为这种变量在内存中只有一个副本,所以无论什么时候操作这种变量都需要考虑线程安全问题。

    线程安全就是多线程访问时,采用了加锁机制,当一个线程访问该类的某个数据时,进行保护,其他线程不能进行访问直到该线程读取完,其他线程才可使用。不会出现数据不一致或者数据污染。 线程不安全就是不提供数据访问保护,有可能出现多个线程先后更改数据造成所得到的数据是脏数据。这里的加锁机制常见的如:synchronized

    synchronized和volatile的区别:

    一旦一个共享变量(类的成员变量、类的静态成员变量)被volatile修饰之后,那么就具备了两层语义:
    1)保证了不同线程对这个变量进行操作时的可见性,即一个线程修改了某个变量的值,这新值对其他线程来说是
    立即可见的。
    2)禁止进行指令重排序。
    volatile本质是在告诉jvm当前变量在寄存器(工作内存)中的值是不确定的,需要从主存中读取;
    synchronized则是锁定当前变量,只有当前线程可以访问该变量,其他线程被阻塞住。

    1.volatile仅能使用在变量级别;
    synchronized则可以使用在变量、方法、和类级别的

    2.volatile仅能实现变量的修改可见性,并不能保证原子性;

    synchronized则可以保证变量的修改可见性和原子性

    3.volatile不会造成线程的阻塞;
    synchronized可能会造成线程的阻塞。

    4.volatile标记的变量不会被编译器优化;
    synchronized标记的变量可以被编译器优化

    看看下面的例子:

    public class ThreadTest {
       public static void main(String[] args) {
             final Counter counter = new Counter(); 
             for (int i = 0; i < 1000; i++) { new Thread(new Runnable() {
                    @Override public void run() {
                        counter.inc();
                    }
                }).start();
            }
            System.out.println(counter);
        }
    
    }
    ```public class Counter { private volatile int count = 0; public void inc() { try {
                Thread.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            count++;
        }
           @Override public String toString() { return "[count=" + count + "]";
        }
    }
    
    

    上面的例子是使用了volatile关键字修饰一个count变量,运行程序,结果会是神马?

    结果不会是1000,或者说不等于1000.

    下面是程序运行了3次的结果:

    [count=971]

    [count=968]

    [count=972]

    可以看出,程序运行的结果是不确定的,这说明了count++并不是原子级别的操作。

    原因是声明为volatile的变量若与自身相关,如以下的声明方式:n=n+1,n++等,那么声明为volatile的变量就不起作用,也就是说关键字volatile无效。

    分析:

    在 java 的内存模型中每一个线程运行时都有一个线程栈,线程栈保存了线程运行时候变量值信息。当线程访问
    某一个对象时候值的时候,首先通过对象的引用找到对应在堆内存的变量的值,然后把堆内存变量的具体值load到线
    程本地内存中,建立一个变量副本,之后线程就不再和对象在堆内存变量值有任何关系,而是直接修改副本变量的值,
    在修改完之后的某一个时刻(线程退出之前),自动把线程变量副本的值回写到对象在堆中变量。这样在堆中的对象
    的值就产生变化了。
    也就是说上面主函数中开启了1000 个子线程,每个线程都有一个变量副本,每个线程修改变量只是临时修改了
    自己的副本,当线程结束时再将修改的值写入在主内存中,这样就出现了线程安全问题。因此结果就不可能等于1000
    了,一般都会小于1000。

    若想将count的操作变为原子级别,可以使用关键字synchronized,即可将类Counter修改为:

    public class Counter {
    
        public static int count = 0;
    
        public synchronized void inc() {
            count++;
        }
    
        public void run() {
            for (int i = 0; i < 10; i++) {
                try {
                    inc();// n=count+1改成了inc()
                    Thread.sleep(3);// 为了使运行结果更随即,延迟3毫秒
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    
        @Override
        public String toString() {
            return "[count=" + count + "]";
        }
    }
    

    程序运行3次的结果:

    [count=1000]

    [count=1000]

    [count=1000]

    参考自<<当年的哥哥>>的博客

    欢迎扫码加入QQ群一起学习讨论。【QQ群:930039263】

    相关文章

      网友评论

        本文标题:Java 线程安全及非线程安全

        本文链接:https://www.haomeiwen.com/subject/tsagsqtx.html