Java常用高级线程操作

标签：

针对Java线程操作一直不太明白，今天找了一本高级教材，有专门介绍Java7支持的线程操作，稍微记录一下各种类和使用条件

1.synchronized对象锁

使用synchronized来锁定一个对象，但是使用在类的方法中的时候会造成整个类的对象被锁，因此对于其他没有此关键字的标记也无法被其他线程操作。

synchronized可以锁定任意代码块，可以锁定任意对对象作为代码块的锁。

2.volatile进行线程同步

volatile作为一个在内存和线程之间同步变量的关键字，不会再本地保存变量的二次拷贝。

3.ReentrantLock超时锁的一个实现，可以实现锁住代码块

在此类对象的.lock()和unlock()之间的代码块是被锁定的块，其下面的方法

lock.tryLock(10, TimeUnit.SECONDS);

可以用来指定超时时间。

4.阻塞队列

这个是针对消费/生产问题的一个实现，一般使用LinkedBlockingQueue来指定具有无限容量的队列，ArrayBlockingQueue是有界的阻塞队列，

还有一个叫LinkedTransferQueue的实现，但是不是太明白书中的例子，应该是一种按需的队列，就是如果队列中有等待使用数据的线程，那么插入数据的线程一旦启动，就会产生需要的所有数据，而一旦没有等待/请求数据的线程，就不产生数据。

5.同步器

信号量Semaphore这个类是用来生成信号量的，信号量的所谓机制就是如果信号量标记有正在处理的事件的时候，所有请求都被驳回，但是如果有空闲就接受请求。

看我写的小例子：

import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;

public class Main {
    public static void main(String[] args){
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        Callable<Integer> callable = new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                return new AtomicInteger(1).incrementAndGet();
            }
        };

        Semaphore semaphore = new Semaphore(4,true);

        try {
            while (true) {
                if (semaphore.tryAcquire(2, TimeUnit.SECONDS)) {
                    Future<Integer> future = executorService.submit(callable);
                    System.out.println(future.get());
                }
            }
        }catch (InterruptedException e){

        }catch (ExecutionException e){

        }finally {
            executorService.shutdown();
        }
    }
}

看到的是ExecutorService创建了10个的线程池（姑且称为线程池），但是信号量是四个，那么执行的时候只能看到四个输出；

import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;

public class Main {
    public static void main(String[] args){
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        Callable<Integer> callable = new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                return new AtomicInteger(1).incrementAndGet();
            }
        };

        Semaphore semaphore = new Semaphore(4,true);

        try {
            while (true) {
                if (semaphore.tryAcquire(2, TimeUnit.SECONDS)) {
                    Future<Integer> future = executorService.submit(callable);
                    System.out.println(future.get());
                }
                semaphore.release();
            }
        }catch (InterruptedException e){

        }catch (ExecutionException e){

        }finally {
            executorService.shutdown();
        }
    }
}

这段是加上了一个叫release的semaphore的方法，此方法释放一个信号量许可，并返回给semaphore。

6.屏障

作为屏障的描述：是一个节点，这个节点是一个会和点，所有操作执行完毕之后都会转到此位置，也就是说所有已经完成任务的线程都要等到其他线程完成，者有点像守护线程的概念。CyclicBarrier实现了屏障，它的构造方法指定一个数字和一个Runnable对象，数字是它调度指挥的线程的数目，Runnable是所有线程都结束之后CyclicBarrier执行的操作，

这个可以解决并行的一些算法运算，那个Runnable就是用来合并结果的（使用分治法思想）。

7.Callable，Future接口

这两个对象都是能够返回县城运行结果的，Callable是被ExecutorService来执行的，Service的submit返回一个Future对象，可以使用它的get方法返回Callable 的运行结果，但是注意只有线程运行完毕之后Future才能有值可以返回

FutureTask是一个既实现Runnable又实现了Future接口的对象，既可以用他的run方法，又可以被submit

8.Executors

这个类的一系列的静态方法来创建线程池并返回ExecutorService对象,newFixedThreadPoll是创建固定大小的线程池，newCacheThreadPool是创建60s之后自动销毁的线程池，这个方便了在小段时间时线程数变化比较大的时候可以节省时间和内存。

newSingleThreadExecutor是创建 一个可以重用的线程。

newScheduledThreadPool创建一个指定大小的线程池，不同的是这个线程池执行线程的操作时按照时序来的，可以指定延迟和次数，可以通过返回的ScheduledExecutorService对象的scheduleAtFixedRate指定一个runnable还有其首次执行的延迟和之后两次调用之间的延迟

9.ForkJoinPool和ForkJoinTask

这两个也是一个用来创建线程池的方法，但是不同的是它们执行的线程可以被合并结果，但是他们执行的任务对象就使用其抽象子类，ForkJoinTask的实现抽象子类：RecursiveTask和RecursiveAction。

前者是可以返回结果，后者是无法返回结果的。计算要实现在compare实现的方法中。执行任务之后可以调用ForkJoinPool的invoke方法来提交一个任务，还有一个名为invokeAll()的方法，但是这个方法如何使用我还不是很了解，因为这个All方法调用的 参数是一个Callable对象集合而非ForkJoinTask。

10.线程安全的随机数生成ThreadLocalRandom类

一般情况下使用它的静态方法就可以生成，比如:

ThreadLocalRandom.current().nextLong(100);

生成的是以0为下限和100的上限的随机数。

这个应当是一个线程安全的随机数生辰器，因此可以考虑在并行运算中使用它。

Java常用高级线程操作

标签：

原文地址：http://www.cnblogs.com/lhyz/p/4509568.html