Java多线程总结

原创
2017/05/22 16:19
阅读数 74

在Java的线程编写,大部分可以用成熟的工具类来实现。

1.ThreadLocal(线程范围内的共享数据)

ThreadLocal<Integer> x = new ThreadLocal<Integer>();

一个线程有一个空间可以共享。可以利用泛型设计复杂的数据结构

也可以利用这个设计线程的单例模式

/**
 * @author wengwh
 * @Date 2014-8-4
 */
public class MyThreadScopeData {
    private static ThreadLocal<MyThreadScopeData> map = new ThreadLocal<MyThreadScopeData>();

    private MyThreadScopeData() {
    };

    public static MyThreadScopeData getThreadInstance() {
        MyThreadScopeData instance = map.get();
        if (instance == null) {
            instance = new MyThreadScopeData();
            map.set(instance);
        }
    }
}

2.线程池

jdk提供了几种类型的线程池,可以根据需要选择其中一种。

ExecutorService threadPool = Executors.newFixedThreadPool(3);
threadPool.execute(new Runnable() {
    
    @Override
    public void run() {
        
    }
});

3.Callable与Future

Future取得的结果类型和Callable返回的结果类型必须一致,这是通过泛型来实现的。

Callable要采用ExecutorService的submit方法提交,返回的future对象可以取消任务。

CompletionService用于提交一组Callable任务,其task方法返回已完成的一个Callable任务对应的Future对象。

Future<String> future = threadPool.submit(new Callable<String>() {
        public String call() {
            return "hello";
        }
    });
try {
    System.out.println(future.get());
} catch (InterruptedException | ExecutionException e) {
    e.printStackTrace();
}

4.Lock锁

比较简单的示例

Lock lock = new ReentrantLock();
lock.lock();
try{
    for(int i=0;i<10;i++){
        System.out.println(i);
    }
}finally{
    lock.unlock();
}

5.读写锁

读写锁就是一种,可以同时读,不能同时读写,写写

代码示例:

ReentrantReadWriteLock writeLock = new ReentrantReadWriteLock();
writeLock.readLock().lock();
writeLock.readLock().unlock();
writeLock.writeLock().lock();
writeLock.readLock().lock();
writeLock.writeLock().unlock();
writeLock.readLock().unlock();

6.Condition

Condition的功能类似在传统线程技术中的Object.wait和Object.notify的功能

可以通过定义2个condition对象来实现生产者模式

Lock lock = new ReentrantLock();
Condition condition = lock.newCondition();
lock.lock();
condition.await();
condition.signal();
lock.unlock();

7.Semaphore

Semaphore可以维护当前访问自身的线程个数,并提供了同步机制。使用Semaphore可以控制同时访问资源的线程个数,例如:实现一个文件允许的并发访问数。

Semaphore sp = new Semaphore(3);
sp.acquire();获取一个信号
sp.release();释放一个信号

8.CyclicBarrier

CyclicBarrier是要等到全部的线程都到达才会一起进行下去

例子:直接到有3个都到达了才会继续下一个

final CyclicBarrier cb = new CyclicBarrier(3);
for(int i=0;i<3;i++){
    Runnable runnable = new Runnable() {
        @Override
        public void run() {
            // TODO Auto-generated method stub
            try {
                Thread.sleep((long)Math.random()*10000);
                System.out.println(cb.getNumberWaiting());
                cb.await();
                System.out.println("end");
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (BrokenBarrierException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    };
    Thread thread = new Thread(runnable);
    thread.start();
}

9.CountDownLatch(倒计时器)

cdOrder.countDown();计数器减一
cdOrder.await();计数器为0时候触发

10.Exchanger(两个线程之间的数据交换)

final Exchanger<String> exchanger = new Exchanger<>();
for(int i=0;i<2;i++){
    Runnable runnable = new Runnable() {
        @Override
        public void run() {
            // TODO Auto-generated method stub
            try {
                
                System.out.println("start-"+Thread.currentThread().getName());
                System.out.println(exchanger.exchange(Thread.currentThread().getName())+Thread.currentThread().getName());
                System.out.println("end-"+Thread.currentThread().getName());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    };
    Thread thread = new Thread(runnable);
    thread.start();
}

11.队列

队列是一种数据结构.它有两个基本操作:在队列尾部加人一个元素,和从队列头部移除一个元素就是说,队列以一种先进先出的方式管理数据。Queue接口与List、Set同一级别,都是继承了Collection接口。LinkedList实现了Queue接口。Queue接口窄化 了对LinkedList的方法的访问权限(即在方法中的参数类型如果是Queue时,就完全只能访问Queue接口所定义的方法了,而不能直接访问 LinkedList的非Queue的方法),以使得只有恰当的方法才可以使用。BlockingQueue 继承了Queue接口。

几种阻塞队列:

LinkedBlockingQueue的容量默认是没有上限的(在不指定时容量为Integer.MAX_VALUE),也可以选择指定其最大容量,它是基于链表的队列,此队列按 FIFO(先进先出)排序元素。

ArrayBlockingQueue在构造时需要指定容量,并可以选择是否需要公平性(默认false),如果公平参数 被设置true,等待时间最长的线程会优先得到处理(其实就是通过将ReentrantLock设置为true来达到这种公平性的:即等待时间最长的线程 会先操作)。通常,公平性会使你在性能上付出代价,只有在的确非常需要的时候再使用它。它是基于数组的阻塞循环队列,此队列按 FIFO(先进先出)原则对元素进行排序。

PriorityBlockingQueue是一个带优先级的队列,而不是先进先出队列。元素按优先级 顺序被移除,该队列也没有上限(看了一下源码,PriorityBlockingQueue是对PriorityQueue的再次包装,是基于堆数据结构 的,而PriorityQueue是没有容量限制的,与ArrayList一样,所以在优先阻塞队列上put时是不会受阻的,但是如果队列为空,取元素的操作take就会阻塞。另外,往入该队列中的元 素要具有比较能力。

DelayQueue(基于PriorityQueue来实现的)是一个存放Delayed 元素的无界阻塞队列,只有在延迟期满时才能从中提取元素。该队列的头部是延迟期满后保存时间最长的 Delayed 元素。如果延迟都还没有期满,则队列没有头部,并且poll将返回null。当一个元素的 getDelay(TimeUnit.NANOSECONDS) 方法返回一个小于或等于零的值时,则出现期满,poll就以移除这个元素了。此队列不允许使用 null 元素。

12.同步集合

Collections工具类

注意:在集合的迭代过程中,不能对集合进行删除操作 这个时候可以用CopyOnWriteArrayList

展开阅读全文
加载中

作者的其它热门文章

打赏
0
0 收藏
分享
打赏
0 评论
0 收藏
0
分享
返回顶部
顶部