网站301是什么/电商运营培训课程

什么是线程安全？

当多个线程访问某个类时，不管运行时环境采用何种调度方式或者这些线程将如何交替执行，并且在调用代码中不需要任何额外的同步或者协同，这个类都能表现出正确的行为，那么就称这个类是线程安全的。

怎么样才能做到线程安全?

解决线程安全的方案:

1.基于JVM的锁

无法解决分布式情况的问题

2.基于数据库的锁(分布式)

耗费资源

3.基于redis的锁(分布式)

可能会出现死锁

4.基于zookeeper的锁(分布式)

最优级

实现好的并发是一件困难的事情，所以很多时候我们都想躲避并发。从下面几点可以避免并发:

线程封闭

无状态的类

让类不可变

volatile

加锁和CAS

安全的发布

ThreadLocal

线程封闭

什么是线程封闭？

就是把对象封装到一个线程里，只有这一个线程能看到此对象。那么这个对象就算不是线程安全的也不会出现任何安全问题。

实现线程封闭有哪些方法？

ad-hoc 线程封闭

这是完全靠实现者控制的线程封闭，他的线程封闭完全靠实现者实现。

Ad-hoc 线程封闭非常脆弱，应该尽量避免使用。

栈封闭

栈封闭是我们编程当中遇到的最多的线程封闭。

什么是栈封闭呢？

简单的说就是局部变量。

多个线程访问一个方法，此方法中的局部变量都会被拷贝一份到线程栈中。所以局部变量是不被多个线程所共享的，也就不会出现并发问题。所以能用局部变量就别用全局的变量，全局变量容易引起并发问题。

无状态的类

没有任何成员变量的类，就叫无状态的类，这种类一定是线程安全的。

无状态就是一次操作，不能保存数据。无状态对象(Stateless Bean)，就是没有实例变量的对象.不能保存数据，是不变类。

如果这个类的方法参数中使用了对象，也是线程安全的吗？比如：

当然也是，为何？因为多线程下的使用，固然 user 这个对象的实例会不正常，但是对于 StatelessClass 这个类的对象实例来说，它并不持有 UserVo 的对象实例，它自己并不会有问题，有问题的是 UserVo 这个类，而非 StatelessClass 本身。

让类不可变

让状态不可变，两种方式：

1，加 final 关键字，对于一个类，所有的成员变量应该是私有的，同样的只要有可能，所有的成员变量应该加上 final 关键字，但是加上 final，要注意如果成员变量又是一个对象时，这个对象所对应的类也要是不可变，才能保证整个类是不可变的。

参见代码

public classImmutableClass {private final inta;private final UserVo user = new UserVo();//不安全

public intgetA() {returna;

}publicUserVo getUser() {returnuser;

}public ImmutableClass(inta) {this.a =a;

}public static classUser{private intage;public intgetAge() {returnage;

}public void setAge(intage) {this.age =age;

}

}

}

2、根本就不提供任何可供修改成员变量的地方，同时成员变量也不作为方法的返回值。

参见代码

public classImmutableClassToo {private final List list = new ArrayList(3);publicImmutableClassToo() {

list.add(1);

list.add(2);

list.add(3);

}public boolean isContain(inti){returnlist.contains(i);

}

}

但是要注意，一旦类的成员变量中有对象，上述的 final 关键字保证不可变并不能保证类的安全性，为何？因为在多线程下，虽然对象的引用不可变，但是对象在堆上的实例是有可能被多个线程同时修改的，没有正确处理的情况下，对象实例在堆中的数据是不可预知的。这就牵涉到了如何安全的发布对象这个问题。

volatile

并不能保证类的线程安全性，只能保证类的可见性，最适合一个线程写，多个线程读的情景。

加锁和CAS

我们最常使用的保证线程安全的手段，使用 synchronized 关键字，使用显式锁，使用各种原子变量，修改数据时使用 CAS 机制等等。

安全的发布

类中持有的成员变量，如果是基本类型，发布出去，并没有关系，因为发布出去的其实是这个变量的一个副本.

参见代码

/*** 演示基本类型的发布*/

public classSafePublish {private inti;publicSafePublish() {

i= 2;

}public intgetI() {returni;

}public static voidmain(String[] args) {

SafePublish safePublish= newSafePublish();int j =safePublish.getI();

System.out.println("before j="+j);

j= 3;

System.out.println("after j="+j);

System.out.println("getI = "+safePublish.getI());

}

}

但是如果类中持有的成员变量是对象的引用，如果这个成员对象不是线程安全的，通过 get 等方法发布出去，会造成这个成员对象本身持有的数据在多线程下不正确的修改，从而造成整个类线程不安全的问题。

参见代码

/*** 不安全的发布*/

public classUnSafePublish {private List list = new ArrayList(3);publicUnSafePublish() {

list.add(1);

list.add(2);

list.add(3);

}publicList getList() {returnlist;

}public static voidmain(String[] args) {

UnSafePublish unSafePublish= newUnSafePublish();

List list =unSafePublish.getList();

System.out.println(list);

list.add(4);

System.out.println(list);

System.out.println(unSafePublish.getList());

}

}

这个 list 发布出去后，是可以被外部线程之间修改，那么在多个线程同时修改的情况下不安全问题是肯定存在的，怎么修正这个问题呢？

我们在发布这对象出去的时候，就应该用线程安全的方式包装这个对象。

参见代码

/*** 安全的发布*/

public classSafePublishToo {private Listlist= Collections.synchronizedList(new ArrayList(3));publicSafePublishToo() {

list.add(1);

list.add(2);

list.add(3);

}publicList getList() {returnlist;

}public static voidmain(String[] args) {

SafePublishToo safePublishToo= newSafePublishToo();

List list =safePublishToo.getList();

System.out.println(list);

list.add(4);

System.out.println(list);

System.out.println(safePublishToo.getList());

}

}

我们将 list 用Collections.synchronizedList 进行包装以后，无论多少线程使用这个 list，就都是线程安全的了。

private Listlist= Collections.synchronizedList(new ArrayList(3));

对于我们自己使用或者声明的类，JDK 自然没有提供这种包装类的办法，但是我们可以仿造这种模式或者委托给线程安全的类，当然，对这种通过 get 等方法发布出去的对象，最根本的解决办法还是应该在实现上就考虑到线程安全问题。

参见以上代码 ↑↑↑

ThreadLocal

ThreadLocal 是实现线程封闭的最好方法。

ThreadLocal 内部维护了一个 Map，Map 的 key 是每个线程的名称，而 Map 的值就是我们要封闭的对象。每个线程中的对象都对应着 Map 中一个值，也就是 ThreadLocal 利用 Map 实现了对象的线程封闭。