java 多线程--------（一）

建立线程的4种方式

一、继承Thread类，复写run方法，run方法中为线程须要执行的逻辑部分，而启动线程调用start方法。小示例见代码，经过Thread.currentThread().getName()能够得到当前线程名称

public class MyThread extends Thread {
   private int i;
   public void run(){
       for(;i<100;i++){
           System.out.println(Thread.currentThread().getName()+" "+i);
       }
   }
};

 public static void main(String[] args) {
        for(int i=0;i<100;i++){
            System.out.println(Thread.currentThread().getName()+""+i);
            if(i==20){
               new MyThread().start();
               new MyThread().start();
            }
        }
    }

二、因为java不支持多继承，当须要继承另外一个类时，与第一种方式冲突。因而能够使用第二种方法，经过实现Runnable接口。复写run方法。代码下

public class MyThread2 implements Runnable{
     private int i;
    @Override
    public void run() {
        for(;i<100;i++){
           System.out.println(Thread.currentThread().getName()+" "+i);
       }
    }
}
    public static void main(String[] args) {
          for(int i=0;i<100;i++){
            System.out.println(Thread.currentThread().getName()+""+i);
            if(i==20){
                MyThread2 myThread2 = new MyThread2();
               new Thread(myThread2).start();
               new Thread(myThread2).start();
            }
     
    }

3使用callable和future，Callable（）与Runable（）不一样的地方主要是，Callable方法有返回值。代码以下

public class CallableDemo implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        int i = 5;
        for(;i<100;i++){
            System.out.println(Thread.currentThread().getName()+" "+i);
        }
        return i;
    }
}


 public static void main(String[] args) {
        CallableDemo callableDemo = new CallableDemo();
        FutureTask<Integer> futureTask = new FutureTask<Integer>(callableDemo);
        for(int i=0;i<100;i++){
            System.out.println(Thread.currentThread().getName()+""+i);
            if(i==20){
               new Thread(futureTask,"有返回的线程:").start();
               try {
                   System.out.println("子线程的返回值" + futureTask.get());
               }catch(Exception e){
                    e.printStackTrace();
               }
            }
        }
    }

四、经过线程池建立线程，首先介绍几个相关的类：Executor，Executors，ExecutorService，Future。Executor为Java1.5后引入的一系列并发库中与executor相关的功能类。
Executors为一个建立线程的工厂，其中提供了4种建立线程的方式。

<一> 建立固定数量的线程。其中参数即为固定线程的数量。

public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }

<二> 建立可缓存的线程，线程超过60s会被回收。当缓存的没有线程能够使用时，则建立新线程使用。该状况下线程是无界的，只要想使用线程会无限的建立，除非发生内存溢出。

public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
    }

<三> 建立一个单线程化的Executor。

public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));
    }

<四> 建立一个支持定时及周期性的任务执行的线程池，多数状况下可用来替代Timer类。

public static ScheduledExecutorService newScheduledThreadPool(
            int corePoolSize, ThreadFactory threadFactory) {
        return new ScheduledThreadPoolExecutor(corePoolSize, threadFactory);
    }