欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页

Java的多线程 博客分类: java 多线程线程池CallableThreadPoolExecutorExecutorService

程序员文章站 2024-03-06 18:45:08
...

1,线程的状态转换:

新建,可运行,运行中,阻塞(等待锁),等待(不确定的等待和指定时间的等待),结束。

Java的多线程
            
    
    博客分类: java 多线程线程池CallableThreadPoolExecutorExecutorService

 

 

线程的join方法和yield方法;

join方法:

线程A中调用线程B的join方法,则线程A将会等待线程B运行结束之后再继续运行。

 

yield方法:

线程调用yield方法,则是让当前正在运行的线程,把CPU时间片让给相同优先级的其他线程去运行。

 

 

interrupt是一个实例方法,设置当前线程的中断标识位。

线程t 在sleep时,t.interrupt()被调用,会抛出InterruptedException;

线程t正在运行时,t.interrupt()被调用,isInterrupted方法会返回true,否则返回false。

isInterrupted是一个实例方法,测试的线程对象是否中断,该方法不会修改中断标志位。

interrupted 是一个静态方法,通过Thread.interrupted调用,判断当前的线程是否中断。(当前线程是指调用this.interrupt()方法的线程)。并且线程的中断状态由该方法清除,即连续调用两次该方法,则第二次会返回false。

让Main线程产生中断效果:

Thread.currentThread().interrupt();

 

System.out.println("Main thread Interrupted:" +Thread.interrupted()); 此时输出 Main thread Interrupted:true

2,Synchronized,Wait 和Notify/NotifyAll:

wait(),notify()和notifyAll()方法是Java.lang.Object类所拥有的。

Wait 和Notify/NotifyAll 必须存在于Synchronized同步块中,否则报错java.lang.IllegalMonitorStateException。

一个线程一旦调用了任意对象的wait()方法,就进入非运行状态,当同一个对象的notify()或者notifyAll()方法被调用,如果调用notify(),只唤醒一个线程,如果调用notifyAll(),该对象上调用wait()方法的全部线程都被唤醒醒。wait和nofity/notifyAll的配对使用,一定要synchronized同一个对象。

由于调用wait和notify都需要获取对象锁,因此调用wait方法后,会自动释放对象锁,之后该对象上的notify方法才能正常被执行。

被唤醒的线程如果要继续执行,也需要重新获取对象锁;调用notify方法的线程也不会立即退出,而是等待执行完synchronized代码块。

不要在字符串常量或全局对象上调用wait方法。字符串常量可能被使用在多个不同的地方。

 

3,线程的创建:

Runnable: 使用Runnable的实例创建线程,线程调用start启动,则自动开始执行run方法,不返回线程执行结果,不能抛出异常。

Callable:泛型参数化接口,通过ExecutorService的sumbit方法,启动call方法来执行,返回Future。因此能返回执行结果,能抛出异常。

ExecutorService支持创建Runnable接口和Callable接口的线程池。

 

Callable线程,通过返回Future获取结果的过程:

 

ExecutorService e = Executors.newFixedThreadPool(5);

CallBackTestThread ca = new CallBackTestThread("Producer Thread " + 21,demo);

Future<String> f = e.submit(ca);

 e.submit->AbstractExecutorService.submit(Callable<T> task) ->RunnableFuture<T> (RunnableFuture<T> ftask = newTaskFor(task);) ->new FutureTask<T>(task)

 

FutureTask实现了Runnable接口,通过传入task,建立一个FutureTask线程,然后通过execute(fTask),添加进线程池。

submit方法即完成了,1:把接口Callable实现的实例task转换位Runnable接口的实例,2,通过execute添加进线程池。

 

AbstractExecutorService类:
public <T> Future<T> submit(Callable<T> task) {
        if (task == null) throw new NullPointerException();
        RunnableFuture<T> ftask = newTaskFor(task);
        execute(ftask);
        return ftask;
    }

 FutureTask同时实现了Future接口。作为Future对象,最后等线程执行完毕作为结果返回。

 

FutureTask的run方法中,直接调用Callable.call()方法,得到结果。

FutureTask保存task运行的状态:

        Possible state transitions:

     * NEW -> COMPLETING -> NORMAL

     * NEW -> COMPLETING -> EXCEPTIONAL

     * NEW -> CANCELLED

     * NEW -> INTERRUPTING -> INTERRUPTED

通过task运行的状态判断是否运行完毕,只有运行的状态是COMPLETING以及大于COMPLETING,才会返回结果,否则阻塞等待。

    private static final int NEW          = 0;
    private static final int COMPLETING   = 1;
    private static final int NORMAL       = 2;
    private static final int EXCEPTIONAL  = 3;
    private static final int CANCELLED    = 4;
    private static final int INTERRUPTING = 5;
    private static final int INTERRUPTED  = 6;
public V get() throws InterruptedException, ExecutionException {
        int s = state;
        if (s <= COMPLETING)
            s = awaitDone(false, 0L);
        return report(s);
    }

 

总结:Callable线程是如何通过获取到Future结果的:返回的Future对象,也是一个Runnable线程,而该线程,是通过包装Callable线程来完成的,实质上运行的run()是直接调用Callable.call()来完成的。而call()会有返回值。

 

4,ThreadLocal的使用

ThreadLocal能保存线程的独立变量,ThreadLocal为每个使用该变量的线程保存一份独立的变量副本,所以每个线程都能独立的修改变量,而不会担心影响到其他的线程。

提供get(),set(T)和remove()方法。

ThreadLocal的实现是使用ThreadLocalMap来保存数据的,而使用ThreadLocal对象本身作为Key。

使用ThreadLocal的注意事项:ThreadLocal的生命周期,与线程一致。而线程池中的线程,是可以不断复用的,因此可能导致包含的ThreadLocal值一直不被释放。

 

5,线程的优先级:

Java的线程优先级范围是1-10,默认是5。10代表最高优先级,1代表最低优先级

多核多线程的平台下,线程的优先级设定,并不能保证线程完全按照优先级来执行。

yield方法只能保证给同优先级的线程提供运行的机会,没有同优先级的线程在等待运行,则yield方法直接忽略。

6,信号量Semaphore:

Semaphore可以控同时访问的线程个数,通过 acquire() 获取一个许可,如果没有就等待,而 release() 释放一个许可

acquire()用来获取一个许可,若无许可能够获得,则会一直等待,直到获得许可。

release()用来释放许可。注意,在释放许可之前,必须先获获得许可。

tryAcquire() :不会阻塞,会立即返回结果。获取成功,返回True,否则返回False。

Semaphore其实和锁有点类似,它一般用于控制对某组资源的访问权限。

 

7,CountDownLunch和CyclicBarrier:

CyclicBarrier的某个线程运行到某个点上之后,该线程即停止运行,直到所有的线程都到达了这个点,所有线程才重新运行。同时CyclicBarrier的值重置,以便下次使用。

如:

CyclicBarrier cyclicBarrier = new CyclicBarrier(10,new NoticeThread());

在线程中,执行cyclicBarrier.await(); 则开始等待,等所有线程都达到这个点,则一起开始重新运行。

CyclicBarrier初始化时,还可以传入一个Runnable类,等条件到达,会自动调用该类。

await(timeout, unit),await方法也可直接传入一个时间和单位,在等待指定时间后,如果CyclicBarrier还

未达到条件,也可让该线程继续往下执行。

 

 

CountDownLunch是在某个线程完成操作后,执行计数器减1。等计数器减到0,则可以继续往下操作。

CountDownLatch countDownLatch = new CountDownLatch(5);

执行时通过countDownLatch.countDown(),让计数器减一

countDownLatch.await();则是阻塞等待计数器到达0.

 

CountDownLatch和CyclicBarrier都能够实现线程之间的等待,只不过它们侧重点不同:

CountDownLatch一般用于某个线程A等待若干个其他线程执行完任务之后,它才执行;

而CyclicBarrier一般用于一组线程互相等待至某个状态,然后这一组线程再同时执行;

另外,CountDownLatch是不能够重用的,而CyclicBarrier是可以重用的