基本概念
首先看一下线程安全与线程不安全的概念：
线程安全就是多线程访问时，采用了加锁机制，当一个线程访问该类的某个数据时，进行保护，其他线程不能进行访问直到该线程读/写完，其他线程才可使用。不会出现数据不一致或者数据污染。
线程不安全就是不提供数据访问保护，有可能出现多个线程先后更改数据造成所得到的数据是脏数据。
学习实践
今天在学习设计模式的时候，对线程安全的概念有些模糊了，又看到说“线程安全问题都是由静态变量引起的”，于是写了下线程不安全的懒汉式单例模式看线程不安全到底是怎么样的。话不多说，代码如下：
public static void main(String[] args) {
new Thread() {
@Override
public void run() {
System.out.println("sub thread1 get Singleton instance: " + Singleton.getInstance().toString());
}
}.start();
new Thread() {
@Override
public void run() {
System.out.println("sub thread2 get Singleton instance: " + Singleton.getInstance().toString());
}
}.start();
System.out.println("main thread get Singleton instance: " + Singleton.getInstance().toString());
}
static class Singleton {
private static Singleton singleton;
private Singleton() {
}
public static Singleton getInstance() {
if (singleton == null) {
singleton = new Singleton();
}
return singleton;
}
}
多次执行发现出现了下面的结果：
sub thread1 get Singleton instance: test.TestSync$Singleton@1670207
sub thread2 get Singleton instance: test.TestSync$Singleton@1e21217
main thread get Singleton instance: test.TestSync$Singleton@1db9742
哇，三个线程都得到了不同的Singleton对象，当然这种情况少一些。也就是说当这几个线程同时执行时，由于CPU的调度不同（执行一个线程，执行一部分代码，让它等待或叫阻塞，接着运行另一个线程，执行一部分又阻塞它......），3个线程可能都判断singleton为null，然后都分别执行singleton = new Singleton();所以产生了3个不同的对象。
这个好理解，但是我有点好奇，难道一般的变量在被多个线程访问时一定是线程安全的？于是我又进行了下面的尝试：
public static void main(String[] args) {
ObjTest objTest = new ObjTest();
if(objTest != null){ // 为了防止线程里的代码先于上一行代码执行
new Thread() {
@Override
public void run() {
System.out.println("sub thread1 get instance: " + objTest.getInstance().toString());
}
}.start();
new Thread() {
@Override
public void run() {
System.out.println("sub thread2 get instance: " + objTest.getInstance().toString());
}
}.start();
new Thread() {
@Override
public void run() {
System.out.println("sub thread3 get instance: " + objTest.getInstance().toString());
}
}.start();
new Thread() {
@Override
public void run() {
System.out.println("sub thread4 get instance: " + objTest.getInstance().toString());
}
}.start();
System.out.println("main thread get instance: " + objTest.getInstance().toString());
}
}
static class ObjTest {
private Object object;
public ObjTest() {
}
public Object getInstance() {
if (object == null) {
object = new Object();
}
return object;
}
}
这次增加了2个子线程来测试，经过多次执行发现同一个对象的普通成员变量也是会有线程不安全的情况。比如结果如下：
sub thread1 get instance: java.lang.Object@e36b9b
sub thread2 get instance: java.lang.Object@eb3e0a
main thread get instance: java.lang.Object@eb3e0a
sub thread3 get instance: java.lang.Object@eb3e0a
sub thread4 get instance: java.lang.Object@eb3e0a
也就是说，当多个线程同时访问成员变量时，不管它是否为静态变量，都有可能出现线程不安全的情况。若每个线程中对静态变量只有读操作，而无写操作，一般来说，这个静态变量是线程安全的；若有多个线程同时执行写操作，一般都需要考虑线程同步，否则的话就可能影响线程安全。
如何解决线程不安全呢
- 同步方法
给多线程访问的成员方法加上synchronized修饰符
public void synchronized doWork(){
// TODO
}
- 使用synchronized修饰的方法，就叫做同步方法，保证线程执行该方法的时候，其他线程只能在方法外等着。
- 同步代码块
synchronized(同步锁对象)
{
// 需要同步操作的代码
}
- 实际上，对象的同步锁只是一个概念，可以想象为在对象上标记了一个锁，谁拿到锁，谁就可以进入代码块，其他线程只能在代码块外面等着，而且注意，在任何时候，Java虚拟机最多允许一个线程拥有该同步锁。
- Java程序运行可以使用任何对象作为同步监听对象，但是一般的，我们把当前并发访问的共同资源作为同步监听对象。
实际上，同步方法和同步代码块差不了多少，在本质上是一样的，两者都用了一个关键字synchronized，synchronized保证了多线程并发访问时的同步操作，避免线程的安全性问题，但是有一个弊端，就是使用synchronized的方法/代码块的性能比不用要低一些，因此如果要用synchronized，建议尽量减小synchronized的作用域。
第一次写博客呢，不知道写得怎么样。有什么意见和建议欢迎评论共同学习进步~(≧▽≦)/啦啦啦
