java 实现多线程的整理：
- Thread实现多线程的两种方式：
(1)继承 Thread类,同时重载 run 方法：
class PrimeThread extends Thread { long minPrime; primeThread(long minPrime) { this.minPrime = minPrime; } public void run() { // compute primes larger than minPrime } }
PrimeThread p = new PrimeThread(143);
p.start();
Thread的源码：
public class Thread implements Runnable { /* Make sure registerNatives is the first thing <clinit> does. */ private static native void registerNatives(); static { registerNatives(); } ......
/* What will be run. */
private Runnable target;
/**
* If this thread was constructed using a separate
* <code>Runnable</code> run object, then that
* <code>Runnable</code> object's <code>run</code> method is called;
* otherwise, this method does nothing and returns.
* <p>
* Subclasses of <code>Thread</code> should override this method.
*
* @see #start()
* @see #stop()
* @see #Thread(ThreadGroup, Runnable, String)
*/
@Override
public void run() {
if (target != null) {
target.run();
}
}
}
(2) 声明一个实现了Runnable接口的类。--- Thread 类其实也是实现了Runnable 接口的类 参见上面的源码
package java.lang; public interface Runnable { public abstract void run(); ｝
如果不需要实现Thread 类中的其他方法，可以仅仅实现Runnable接口中的Run()方法来实现多线程。
"This is important because classes should not be subclassed unless the programmer intends on modifying or enhancing the fundamental behavior of the class." --- Arthur van Hoff
--- 因为当程序员不准备修改或者增强这个类的功能的时候，就不应该成为这个类的子类。
class PrimeRun implements Runnable { long minPrime; PrimeRun(long minPrime){ this.minPrime = minPrime; } public void run() { //compute primes larger than minPrime .... } }
PrimeRun p = new PrimeRun(143); new Thread(p).start();
2. Executors
Executor 接口
一个执行提交Runnable 任务的对象。对任务的提交与任务的执行，线程的使用，调度进行解耦。
取代 new Thread(new(RunnableTask())).start()
转而使用：
Executor executor = anExecutor;
executor.execute(new RunnableTask1());
executor.execute(new RunnableTask2());
简单的用法：
class DirectExecutor implements Executor { public void execute(Runnable r) { r.run(); } } class ThreadPerTaskExecutor implements Executor { public void execute(Runnable r) { new Thread(r).start(); } }
一个复合的Executor：
class SerialExecutor implements Executor { final Queue<Runnable> tasks = new ArrayDeque<Runnable>(); final Executor executor; Runnable active; SerialExecutor(Executor executor) { this.executor = executor; } public synchronized void execute(final Runnable r) { tasks.offer(new Runnable() { public void run() { try { r.run(); } finally { scheduleNext(); } } }); if (active == null) { scheduleNext(); } } protected synchronized void scheduleNext() { if ((active = tasks.poll()) != null) { executor.execute(active); } } }
interface ExecutorService
接口继承Executor提供了方法来管理终止以及可以产生Future结果的同步或者异步任务。
public interface ExecutorService extends Executor {
void shutdown();//停止说有的任务，不会再接收新的任务
List<Runnable> shutdownNow();//停止全部活跃的任务，停止等待的任务，返回等待执行任务的列表。
boolean isShutdown(); // 返回true 如果executor 已经被停止
boolean isTerminated(); //如果全部的任务在shutDown后都完成了 返回为true.只有在shutdown()或者 shutdownNow() 被调用后才会返回true.
boolean awaitTermination(long timeout, TimeUnit) throws InterruptedException; //阻塞直到所有的任务在shutdown()请求完成后，或者超时发生，或者现有的线程中断。
<T> Future<T> submit(Callable<T> task); //提交一个值返回的任务运行，同时返回Future类，通过Future 的get()方法可以获得任务的执行结果。
<T> Future<T> submit(Runnable task, T result);
Future<?> submit(Runnable task);//提交一个Runnable 任务执行，返回一个Future代表这个任务。
<T> List<Future<T>> invokeAll(Colleaciton<? extends Callable<T>> tasks) throws InterruptedException;//执行指定的多个任务，返回Future的list，包含他们的状态，以及运行完成的结果。
<T> List<Future<T>> invokeAll(Collectio<? extends Callable<T>> tasks, long timeout, TimeUnit unit) throws InterruptedException;//执行给定的任务，返回Future的列表，知道所有的任务都完成或者超时时间达到。
<T> T invokeAny(Collection<? extends Callable<T>> tasks) throws InterruptedException, ExecutionException;//执行给定的任务，返回任意一个完成的结果。
<T> T invokeAny(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException;//执行给定的任务，直到任务在超时时间内完成
}
class Executors
支持运行异步任务，管理一个线程池，无需手动去创建新的线程。
public class executors { public static void main(String[] args){ ExecutorService executor = Executors.newSingleThreadExecutor(); executor.submit(() -> { String threadName = Thread.currentThread().getName(); System.out.println("Hello " + threadName); }); } }
但是java进程没有结束，Executors必须显示的停止，可以调用上面ExecutorService中的方法来终止：shutdown() 会等待当前的任务运行完成，shutdownNow() 会终止所有的当前正在运行的任务并且立即关闭executor。
import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.TimeUnit; public class executors { public static void main(String[] args){ ExecutorService executor = Executors.newSingleThreadExecutor(); executor.submit(() -> { String threadName = Thread.currentThread().getName(); System.out.println("Hello " + threadName); }); try { System.out.println("attempt to shutdown executor"); executor.shutdown(); executor.awaitTermination(5, TimeUnit.SECONDS); } catch (InterruptedException e) { System.err.println("tasks interrupted"); } finally { if(!executor.isTerminated()) { System.err.println("cancel non-finished tasks"); } executor.shutdownNow(); System.out.println("shutdown finished"); } } }
Executors 还支持另外一种类型的任务：Callable。Callable会返回一个值。
import java.util.concurrent.*; public class callable{ public static void main(String[] args) throws IllegalStateException,InterruptedException, ExecutionException{ Callable<Integer> task = () -> {
try { TimeUnit.SECONDS.sleep(1); return 123; } catch (InterruptedException e) { throw new IllegalStateException("task interrupted", e); } }; ExecutorService executor = Executors.newFixedThreadPool(1); Future<Integer> future = executor.submit(task); System.out.println("future done? " + future.isDone()); Integer res = future.get(); System.out.println("future done? " + future.isDone()); System.out.print("result : " + res); executor.shutdownNow(); } }
Executors 可以通过invokeAll()一次批量提交多个callable任务。
import java.util.concurrent.*; import java.util.*; public class moreCallable{ public static void main(String[] args) throws InterruptedException{ ExecutorService executor = Executors.newWorkStealingPool(); List<Callable<String>> callables = Arrays.asList( () -> "task1", () -> "task2", () -> "task3"); executor.invokeAll(callables).stream().map(future -> { try{ return future.get(); }catch (Exception e) { throw new IllegalStateException(e); } }).forEach(System.out::println); } }
-----
Executors 是一个包含有很多static静态方法的类，使用时，可以作为一个工具类使用，
Executors.newWorkStealingPool() 这个方法又拖出来一个类：ForkJoinPool(extends AbstractExecutorService (since 1.7))
后续继续写 Future，ForkJoinPool 以及线程的调度：ScheduledExecutorService。
参考：
http://www.open-open.com/lib/view/open1431307471966.html
https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/package-summary.html
http://www.cnblogs.com/lucky_dai/p/5509261.html
java源码