欢迎您的访问
专注架构,Java,数据结构算法,Python技术分享

谈谈对Java线程安全与不安全的理解

当我们查看JDK API的时候,总会发现一些类说明写着,线程安全或者线程不安全,比如说到StringBuilder中,有这么一句,“将StringBuilder 的实例用于多个线程是不安全的。如果需要这样的同步,则建议使用StringBuffer。”

提到StringBuffer时,说到“StringBuffer是线程安全的可变字符序列,一个类似于String的字符串缓冲区,虽然在任意时间点上它都包含某种特定的字符序列,但通过某些方法调用可以改变该序列的长度和内容。可将字符串缓冲区安全地用于多个线程。可以在必要时对这些方法进行同步,因此任意特定实例上的所有操作就好像是以串行顺序发生的,该顺序与所涉及的每个线程进行的方法调用顺序一致”。

StringBuilder是一个可变的字符序列,此类提供一个与StringBuffe兼容的API,但不保证同步。该类被设计用作StringBuffer的一个简易替换,用在字符串缓冲区被单个线程使用的时候(这种情况很普遍)。如果可能,建议优先采用该类,因为在大多数实现中,它比StringBuffer要快。将StringBuilder的实例用于多个线程是不安全的,如果需要这样的同步,则建议使用StringBuffer。

根据以上JDK文档中对StringBuffer和StringBuilder的描述,得到对String、StringBuilder与StringBuffer三者使用情况的总结:

  • 如果要操作少量的数据用String
  • 单线程操作字符串缓冲区下操作大量数据StringBuilder
  • 多线程操作字符串缓冲区下操作大量数据StringBuffer

那么下面手动创建一个线程不安全的类,然后在多线程中使用这个类,看看有什么效果。

public class Count {
    private int num;
    //public void count() {
    //    for(int i = 1; i <= 100; i++) {
    //        num += i;
    //    }
    //    System.out.println(Thread.currentThread().getName() + "-" + num);
    //}

    public int getNum() {
        return num;
    }

    public void increment(int i) {
        num = num + i;
    }
}

在这个类中的increment方法实现num变量与指定变量作加法。

public class ThreadTest {
    public static void main(String[] args) {
        Runnable runnable = new Runnable() {
            Count count = new Count();
            @Override
            public void run() {
                for (int i = 0; i < 1000; i++) {
                    count.increment(1);
                }
                System.out.println(Thread.currentThread().getName() + "-" + count.getNum());
                try {
                    Thread.sleep(2);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };

        for(int i = 0; i < 10; i++) {
            Thread thread = new Thread(runnable);
            thread.start();
        }
    }
}

这里启动了10个线程,看一下输出结果:

Thread-0-1660
Thread-2-2660
Thread-3-3660
Thread-1-1660
Thread-4-4882
Thread-5-5579
Thread-6-6579
Thread-7-7579
Thread-8-8579
Thread-9-9579

期望的结果是每个线程都能输出1000,但实际上每个线程的输出值都不一样而且不是整数,多运行几次每次的输出结果都不一样,要想得到我们期望的结果,有几种解决方案:

1、将累加逻辑移到Count类中,并且使用局部变量而不是成员变量;

public class Count {
    public void count() {
        int number = 0;
        for(int i = 0; i < 1000; i++) {
            number += 1;
        }
        System.out.println(Thread.currentThread().getName() + "-" + number);
    }
}

~

public class ThreadTest {
    public static void main(String[] args) {
        Runnable runnable = new Runnable() {
            Count count = new Count();
            @Override
            public void run() {
                count.count();
                try {
                    Thread.sleep(2);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };

        for(int i = 0; i < 10; i++) {
            Thread thread = new Thread(runnable);
            thread.start();
        }
    }
}

运行结果如下:

Thread-0-1000
Thread-3-1000
Thread-4-1000
Thread-1-1000
Thread-2-1000
Thread-5-1000
Thread-6-1000
Thread-7-1000
Thread-8-1000
Thread-9-1000

2、将线程类成员变量拿到run方法中,这时count引用是线程内的局部变量;

public class ThreadTest {
    public static void main(String[] args) {
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                Count count = new Count();
                for (int i = 0; i < 1000; i++) {
                    count.increment(1);
                }
                System.out.println(Thread.currentThread().getName() + "-" + count.getNum());
                try {
                    Thread.sleep(2);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };

        for(int i = 0; i < 10; i++) {
            Thread thread = new Thread(runnable);
            thread.start();
        }
    }
}

运行结果如下:

Thread-1-1000
Thread-3-1000
Thread-2-1000
Thread-0-1000
Thread-5-1000
Thread-4-1000
Thread-6-1000
Thread-7-1000
Thread-8-1000
Thread-9-1000

3、每次启动一个线程使用不同的线程类,不推荐。

通过上述测试,我们发现,存在成员变量的类(即有状态的类)用于多线程时是不安全的,不安全体现在这个成员变量可能发生非原子性的操作,而变量定义在方法内也就是局部变量是线程安全的。

想想在使用struts1时,不推荐创建成员变量,因为action是单例的,如果创建了成员变量,就会存在线程不安全的隐患,而struts2是每一次请求都会创建一个action,就不用考虑线程安全的问题。所以,日常开发中,通常需要考虑成员变量或者说全局变量在多线程环境下,是否会引发一些问题。

要说明线程同步问题首先要说明Java线程的两个特性,可见性和有序性。

多个线程之间是不能直接传递数据进行交互的,它们之间的交互只能通过共享变量来实现。拿上面的例子来说明,在多个线程之间共享了Count类的一个实例,这个对象是被创建在主内存(堆内存)中,每个线程都有自己的工作内存(线程栈),工作内存存储了主内存count对象的一个副本,当线程操作count对象时,首先从主内存复制count对象到工作内存中,然后执行代码count.count(),改变了num值,最后用工作内存中的count刷新主内存的 count。当一个对象在多个工作内存中都存在副本时,如果一个工作内存刷新了主内存中的共享变量,其它线程也应该能够看到被修改后的值,此为可见性。

多个线程执行时,CPU对线程的调度是随机的,我们不知道当前程序被执行到哪步就切换到了下一个线程,一个最经典的例子就是银行汇款问题,一个银行账户存款100,这时一个人从该账户取10元,同时另一个人向该账户汇10元,那么余额应该还是100。那么此时可能发生这种情况,A线程负责取款,B线程负责汇款,A从主内存读到100,B从主内存读到100,A执行减10操作,并将数据刷新到主内存,这时主内存数据100-10=90,而B内存执行加10操作,并将数据刷新到主内存,最后主内存数据100+10=110,显然这是一个严重的问题,我们要保证A线程和B线程有序执行,先取款后汇款或者先汇款后取款,此为有序性。

在Web开发方面,Servlet是否是线程安全的呢?

Servlet不是线程安全的。要解释为什么Servlet为什么不是线程安全的,需要了解Servlet容器(如Tomcat)是如何响应HTTP请求的。当Tomcat接收到Client的HTTP请求时,Tomcat从线程池中取出一个线程,之后找到该请求对应的Servlet对象并进行初始化,之后调用service()方法。

要注意的是每一个Servlet对象在Tomcat容器中只有一个实例对象,即是单例模式。如果多个HTTP请求请求的是同一个Servlet,那么这两个HTTP请求对应的线程将并发调用Servlet的service()方法。如果的Thread1和Thread2调用了同一个Servlet1,Servlet1中定义了成员变量或静态变量,那么可能会发生线程安全问题(因为所有的线程都可能使用这些变量)。

像Servlet这样的类,在Web 容器中创建以后,会被传递给每个访问Web应用的用户线程执行,这个类就不是线程安全的。但这并不意味着一定会引发线程安全问题,如果Servlet类里没有成员变量,即使多线程同时执行这个Servlet实例的方法,也不会造成成员变量冲突。

这种对象被称作无状态对象,也就是说对象不记录状态,执行这个对象的任何方法都不会改变对象的状态,也就不会有线程安全问题了。事实上,Web开发实践中,常见的Service类、DAO类,都被设计成无状态对象,所以虽然我们开发的Web应用都是多线程的应用,因为Web容器一定会创建多线程来执行我们的代码,但是我们开发中却可以很少考虑线程安全的问题。

来源:blog.csdn.net/fuzhongmin05/article/details/59110866

赞(0) 打赏
版权归原创作者所有,任何形式转载请联系作者;码农code之路 » 谈谈对Java线程安全与不安全的理解

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

微信扫一扫打赏