Java多线程 之 临界区、ThreadLocal


1.临界区

临界区就是在同一时刻只能有一个任务访问的代码区。在java中通常使用下面的方式来实现:

synchronized(syncObject) { 
    //critical section
}

当然也可以使用Lock对象来实现临界区。
要访问临界区就要先获得syncObject这个对象的锁。注意, 每个java对象都隐含有一把锁
使用临界区的执行效率要比使用synchronized方法的执行效率要高,因为其锁粒度更小。
synchronized关键字不属于方法特征签名的一部分,所以可以在覆盖方法的时候加上去。也就是说,在父类的方法声明上可以没有synchronized关键字,而在子类覆盖该方法时加上synchronized关键字。
注意:使用synchronized是对哪个对象加的锁。
如果在一个类内部都是使用synchronized关键字定义了方法f(),g()。那么当使用这个类的实例调用f()时,就不能再调用g()方法。

2.ThreadLocal

前面的介绍都是所有任务共享同一个变量造成的资源竞争,因此需要对其进行同步。还有一种解决并发问题的技术是:每个任务都有一份该变量的拷贝,也就是ThreadLocal。
下面是一个ThreadLocal的例子:

package org.fan.learn.thread.share;
import java.lang.reflect.Executable;
import java.util.Random;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
/**
 * Created by fan on 2016/6/29.
 */
class Accessor implements Runnable {
    private final int id;
    public Accessor(int id) {
        this.id = id;
    }
    public void run() {
        while (!Thread.currentThread().isInterrupted()) {
            ThreadLocalTest.increament();
            System.out.println(this);
            Thread.yield();
        }
    }
    @Override
    public String toString() {
        return "#" + id + ":" + ThreadLocalTest.get();
    }
}
public class ThreadLocalTest {
    private static ThreadLocal<Integer> threadLocal =
            new ThreadLocal<Integer>() {
                private Random random = new Random(10);
                //覆盖了ThreadLocal中的initialValue方法
                protected synchronized Integer initialValue() {
                    return random.nextInt(1000);
                }
            };
    public static void increament() {
        threadLocal.set(threadLocal.get() + 1);
    }
    public static Integer get() {
        return threadLocal.get();
    }
    public static void main(String[] args) throws InterruptedException {
        ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i = 0; i < 5; i++) {
            executorService.execute(new Accessor(i));
        }
        TimeUnit.MILLISECONDS.sleep(300);  //300ms
        executorService.shutdownNow();
    }
}

部分执行结果:

#0:114
#0:115
#0:116
#3:381
#4:294
#3:382
#3:383
#2:291
#1:247
#2:292
#2:293
#2:294

从运行结果来看,每个线程都维护了自己的变量副本。

使用ThreadLocal一般都会设置成静态的类型,并且仅使用set、get方法。
注意,在ThreadLocal变量初始化时,覆盖了ThreadLocal的initialValue方法,而且在内部使用synchronized关键字对其进行初始化。由于threadLocal变量是一个静态的,当每个线程执行时,都会加载这个静态的变量,这时在random.nextInt时产生竞争。由于这个静态变量时ThreadLocal的,所以每个任务都有一个副本,而且都会进行初始化。
这个有可能说的不准确,还是要等再看了《深入理解JVM》之后再来阐述。

3.常见的同步方案

(1)synchronized首选
(2)ReentrantLock
(3)Atomic原子类,效率较高,可用于优化
(4)ThreadLocal,特殊情况上使用,spring有介绍。以后再补充。


原文链接:https://blog.csdn.net/fan2012huan/article/details/51781443