独立线程与线程池

---

1.继承Thread
package com.example;

/**
 * 继承Thread
 */
public class ThreadTest{
    public static void main(String[] args) throws InterruptedException {
        for(int i=0;i<100;i++){
            System.out.println("main方法中的线程"+Thread.currentThread().getName()+" "+i);
            if(i == 30){
                Thread myThread = new ThreadT();
                myThread.setName("myThread1");
                Thread myThread1 = new ThreadT();
                myThread1.setName("myThread2");
                myThread.start();
                myThread1.start();
                // join(), 当前线程暂停, 等待指定的线程执行结束后, 当前线程再继续
                // join(int), 可以等待指定的毫秒之后继续
                myThread.join();
                myThread1.join();
            }

        }

    }

}
class ThreadT extends Thread{
    private  int i=0;
    @Override
    public void run(){
        for(int j=0;j<10;j++){
            System.out.println("自定义线程:"+Thread.currentThread().getName()+" "+j);
        }
    }
}

---

2.比较Thread与Runnable
package com.example;

/**
 * 继承Thread未共享count
 */
public class ThreadTest1 {

    public static void main(String[] args) {
        // Thread类中有start()方法，调用父类start()执行子类run()
        new MyThread().start();
        new MyThread().start();
        new MyThread().start();
    }

}
class MyThread extends Thread{
    private int count = 10;
    @Override
    public void run() {
        while(count > 0)
            System.out.println(count--);
    }
}

---

3.实现Runnable
package com.example;

/**
 * runnable新建的三个线程共享了一个count,
 * 适用于列如抢票的场景,而thread是三个线程独有的无法共享
 */
public class ThreadRunnableTest1  {
    public static void main(String[] args) {
        Runnable myThread = new MyThread2();
        new Thread(myThread).start();
        new Thread(myThread).start();
        new Thread(myThread).start();
    }

}
class MyThread2 implements Runnable{
    private int count = 10;
    @Override
    public void run() {
        while(count > 0)
            System.out.println(count--);
    }
}

---

4.线程池（常用）

原因：主要是每次新建线程时都需要分配内存，若没有限制当请求过多时会造成内存溢出；次要是效率会比每次new线程效率高些。

 Callable 和 Runnable的区别：
 1.返回值:  callable又返回值,runnable无返回值, 
 2.使用范围  callable只能用在线程池中而runnable可用于独立线程中
 3.启动方式  在线程池中runnable使用pool.execute(runnable)无返回对象;  callable使用submit方式返回Future对象 
 4.异常处理:Runnable提供run方法，无法通过throws抛出异常，所有CheckedException必须在run方法内部处理。Callable提供call方法，直接抛出Exception异常。
 注java8中没有这个包需增加maven依赖  com.google.guava

package com.example;

import com.google.common.util.concurrent.ThreadFactoryBuilder;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.*;

public class ThreadPoolTest {
    private static  int  NUMBER_OF_CORES = Runtime.getRuntime().availableProcessors();
    private static ThreadFactory namedThreadFactory = new ThreadFactoryBuilder()
            .setNameFormat("demo-pool-%d").build();
    private static ExecutorService pool = new ThreadPoolExecutor(NUMBER_OF_CORES, 200,
            0L, TimeUnit.MILLISECONDS,
            new LinkedBlockingQueue<Runnable>(1024), namedThreadFactory, new ThreadPoolExecutor.AbortPolicy());
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        List<Future<Integer>> list = new ArrayList<>();
        for (int i = 0; i < 3; i++) {
            Future<Integer> future = pool.submit(new Callable<Integer>(){
                @Override
                public Integer call() throws Exception {
                    int sum = 0;
                    for (int i = 0; i <= 100; i++) {
                        sum += i;
                    }
                    return sum;
                }
            });
            list.add(future);
        }
        pool.shutdown();
        for (Future<Integer> future : list) {
            System.out.println(future.get());
        }

    }
}

class SubThread implements Runnable{
    private int count = 10;
    public SubThread() {

    }
    public void run() {
        System.out.println(Thread.currentThread().getName()+"|||"+count--);
    }
}