1。Servlet是非线程安全的。
避免在servlet类中定义未受锁保护的属性
public class unsafe implements servlet {
//加入这个属性后，servlet不再是无状态了。多线程同时访问count对象会出现线程安全问题
private long count = 0;
public long getCount(){
return count;
}
public void service(..){
....
}
}2。当代码逻辑的正确性取决于多个线程的交替执行的时序时，就会出现竞争条件。
最常见的就是：“先检查后操作”，当其中一个线程通过检查，准备进行操作的时候，要操作的变量可能在这期间被别的线程改变了。
解决方法：a)使用原子操作 b)加锁
3。如果只是将每个方法都作为同步方法，例如Vector，那么不足以保证Vector上的复合操作都是原子的。
还是“先检查后操作”的例子。
if(vector.contains(element)){
vector.add(element)
}线程1：获得锁，检查通过vector不包含element，释放锁—————————------------——————————————————>获得锁，vector.add(element)，释放锁
线程2： 获得锁，检查通过vector不包含element，vector.add(element)，释放锁
所以虽然synchronized可以确保单个操作的原子性，但如果把多个操作作为一个复合操作需要额外的加锁
线程1：获得锁，检查通过vector不包含element，vector.add(element)，释放锁
线程2： 获得锁，检查通过vector已经包含element，释放锁
4。内存可见性问题。
在一些场合需要当一个线程修改了一个对象的状态以后，需要其他所有的线程都能立马的看到这个对象的变化。
举一个不安全的例子：
public class UnsafeClass{
private static boolean flag;
private static int num;
private static class ReaderThread extend Thread{
public void run(){
while(!flag)
Thread.yield();
System.out.println(num);
}
}
public static void main(){
new ReaderThread().start();
number = 42;
flag = true;
}
}书本原话：上面这个class可能会永远运行下去。我猜这句话是因为主线程里面修改完flag=true后，并没有立刻写入到主存，即使写入后，ReaderThread也并没有立刻去主存读取并把存储在ReaderThread线程栈中的flag=false更新为true，导致ReaderThread的栈线程里读到的flag一直是false。
还有可能是print出来的num是0：这是因为JVM为了充分地利用现代多核处理器的强大性能。例如，在缺少同步的情况下，Java内存模型允许编译器对操作顺序进行重排序。此外，它还允许CPU对操作顺序进行重排序。
所以有可能被重排序后变成：
new ReaderThread().start();
falg = true;
number = 42;
那么为了解决上面的现象：
一。Synchronize不用说了
二。Volatile，它的作用是：
①加入内存栅栏，强迫改动里面生效，从缓存中立马写入到主存，并使其他线程保存的这个变量的缓存失效，迫使其他线程从内存中取得这个变量的最新值
②使jvm不对改变量上的操作与其他内存操作进行重排序。
5。注意“this引用溢出”
如果，在构造函数A中启动一个线程时，无论这个线程是显示创建（直接在构造函数中创建一个线程），还是隐式创建（线程作为传入构造函数的参数对象的一个内部类），
A类的引用都会被新创建的线程共享。也就是新创建的线程可以调用A类中的方法和属性。使用外部类名称.this就可以在内部类中引用外部类的对象了
例子：
class Escape {
private String a = null;
public Escape(){
new Thread(new Runnable(){
@Override
public void run() {
//注意，它能直接调用到Escape类中的doSomething()函数，从而打印出了还没有初始化完的a对象
doSomething();
//它能直接调用到Escape类中的a属性
System.out.println(a);
}
}).start();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//这个时候a才初始化完
a = "finish";
}
private void doSomething(){
System.out.println(a);
}
}
public class ThisEscape{
public static void main(String args[]){
Escape demo = new Escape();
}
}
null
null
因为在Escape类的构造函数的创建的线程对象 调用了Escape还没有初始化完成的a对象
6。ThreadLocal类
public void set(T value) {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);
else
createMap(t, value);
}
7。同步容器的替代者
同步容器类包括 Vector和HashTable，以及使用Collections.synchronizedXxx等工厂方法创建的同步类。
这些同步容器类的特点是：每个公有的方法都进行同步，使得每次只有一个线程能够访问容器的状态。
同步容器类的问题：由于只是在类中的每单个函数上进行了同步，那么在进行需要多个函数参与的复合操作的时候，比如“若没有则添加”，就会出现问题。
需要在最外层加锁：
public class Test {
Vector vector = new Vector();
public void ifNotAddSafe(String value){
synchronized(vector){
if(!vector.contains(value)){
vector.add(value);
}
}
}
}并且在迭代vector容器的时候，如果有其他线程对vector里面的内容做了修改就会出错
所以需要做迭代操作的时候也在最外层加锁
public class Test {
Vector vector = new Vector();
public void iteratorSafe(){
synchronized (vector) {
for(int i=0;i<vector.size();i++){
....
}
}
}
}
针对上面各种问题，java5.0提供了多种并发容器来改进同步容器在多线程并发环境中的使用性能。
增加了ConcurrentHashMap 替代 同步且基于散列的Map（《ConcurrentHashMap分析》）
CopyOnWriteArrayList 用于在遍历操作为主要操作的情况下代替同步的List。
在每次对容器做出修改时，都会创建并重新发布一个新的容器副本，在修改前对容器进行迭代的其他线程就不会出现错误
在新的ConcurrentMap接口中增加了对一些常见的复合操作的支持，比如“若没有则添加”
8。同步工具类
- 确保某个计算在其所需要的所有资源都被初始化完了以后才开始执行
- 确保某个服务在其所依赖的所有其他服务都已经启动之后才启动。
- 等待直到某个操作的所有参与者都就绪再继续执行。
package bisuo;
import java.util.concurrent.CountDownLatch;
public class Test {
public static void main(String[] args) {
//定义有10个事件，需要10个事件都完成才能开门
final CountDownLatch gate = new CountDownLatch(10);
long startTime = System.currentTimeMillis();
//10个线程完成10个事件
for(int i=0; i<10;i++){
Thread t = new Thread() {
public void run() {
try {
//do something
Thread.sleep(10000);
}catch(Exception e){
e.printStackTrace();
}finally{
//完成一个count减1
gate.countDown();
}
}
};
t.start();
}
try {
//等待直到count为0
gate.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
long endTime = System.currentTimeMillis();
long spendTime = endTime - startTime;
System.out.println(spendTime);
}
}
2.FutureTask类
public class TestFutureTask {
public static void main(String[] args) {
final FutureTask<Result> future = new FutureTask<Result>(new Callable<Result>(){
public Result call(){
try {
//模拟任务执行
Thread.sleep(10000);
} catch (InterruptedException e) {
e.printStackTrace();
}
Result result = new Result();
return result;
}
});
//定义一个线程去执行这个任务
final Thread thread = new Thread(future);
thread.start();
try {
//这一步会一直阻塞直到thread运行结束,result返回
Result result = future.get();
System.out.println("end");
} catch (InterruptedException | ExecutionException e) {
e.printStackTrace();
}
}
}Semaphore中管理着一组虚拟的许可，许可的初始数量可以通过构造函数来指定。
在执行操作中需要先获得许可，操作完以后释放，如果没有可用的许可了，那么acquire（）——获得许可操作将一直阻塞直到有可用的许可了
章节总结：
可变状态越少，就越容易确保线程的安全性，所以尽量将域声明为final类型，除非需要它们是可变的。不可变对象一定是线程安全的
当保护同一个不变性条件中的所有变量时，要使用同一个锁，在执行复合操作期间，要持有锁。
扫一扫
145
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
