java中创建多线程4种方式以及实现接口的优点

多线程创建方式有4种

创建线程的第一种方式。继承Thread类 
1.继承Thread类 
2.重写Thread类中的run方法--目的将自定义代码存储在run方法.让线程执行
3.调用线程的start()方法改方法有两个作用1启动线程 2让jvm调用run方法执行线程任务

 

创建线程的第二种方式。实现Runnable接口。
1，定义类实现Runnable接口：避免了继承Thread类的单继承局限性。
2，覆盖接口中的run方法。将线程任务代码定义到run方法中。
3，创建Thread类的对象：只有创建Thread类的对象才可以创建线程。
4，将Runnable接口的子类对象作为参数传递给Thread类的构造函数。
因为线程已被封装到Runnable接口的run方法中，而这个run方法所属于Runnable接口的子类对象，
所以将这个子类对象作为参数传递给Thread的构造函数，这样，线程对象创建时就可以明确要运行的线程的任务。
5，调用Thread类的start方法开启线程。

第二种方式实现Runnable接口避免了单继承的局限性，所以较为常用。
实现Runnable接口的方式，更加的符合面向对象，线程分为两部分，一部分线程对象，一部分线程任务。
继承Thread类：线程对象和线程任务耦合在一起。一旦创建Thread类的子类对象，既是线程对象，有又有线程任务。
实现runnable接口：将线程任务单独分离出来封装成对象，类型就是Runnable接口类型。
Runnable接口对线程对象和线程任务进行解耦。

 

//通过查看源码了解一下将runnable接口的子类对象作为参数传递给Thread构造函数的原因。
class Thread{

    private Runnable target;

    Thread(Runnable target)
    {
        this.target = target;
    }
    public void run() {
        if (target != null) {
            target.run();
        }
    }
    public void start()
    {
        run();
    }
}

Runnable d = new Demo();
Thread t = new Thread(d);
t.start();

class Demo implements Runnable
{
    private String name;
    Demo(String name)
    {
        this.name = name;
    }
    //覆盖了接口Runnable中的run方法。
    public void run()
    {
        for(int x=1; x<=20; x++)
        {
            System.out.println("name="+name+"..."+Thread.currentThread().getName()+"..."+x);
        }
    }
}

class ThreadDemo2 
{
    public static void main(String[] args) 
    {
        //创建Runnable子类的对象。注意它并不是线程对象。
        Demo d = new Demo("Demo");
        //创建Thread类的对象，将Runnable接口的子类对象作为参数传递给Thread类的构造函数。
        Thread t1 = new Thread(d);
        Thread t2 = new Thread(d);
        //将线程启动。
        t1.start();
        t2.start();
        
        System.out.println(Thread.currentThread().getName()+"----->");


    }
}

 

第三种方式:

* 实现 Runnable
* 实现Callable
* 它俩区别：Runnable run方法没有返回值
* Callable call方法有返回值

* 创建线程第三种方式：实现Callable接口
* new Thread() api构造方法中没有直接传递Callable接口的 只有传Runnable
* 思考是不是有一个桥梁 将Callable和Runnable它俩联系起来的
* 这个桥梁就是FutureTask
*
* FutureTask 构造中传递的是Callable接口， 间接实现Runnable接口
* 因为FutureTask间接实现Runnable接口所以可以传递到new Thread()构造方法中

class MyThread implements Callable<Integer> {

    @Override
    public Integer call() throws Exception {
        System.out.println(Thread.currentThread().getName()+"**************come in Callable");
        return 1024;
    }
    
}
public class CallableDemo {
    
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        FutureTask<Integer> task = new FutureTask<>(new MyThread());
        
        new Thread(task, "AA").start();
//        new Thread(task, "BB").start(); //多个线程抢一个task，只会执行一次,想要执行多次起多个FutureTask

        
        int result01 = 100;
        
        int result02 = task.get(); //建议放到最后，否则会造成阻塞
        
//        System.out.println("******result:"+task.get());
        System.out.println("******result:"+(result01+result02));
    }

}

 

第4种方式:线程池

/**
 * 生产环境 都是自定义线程池
 * 
 * 合理配置线程池 如何考虑
 * 
 * CPU密集型   公式 ：cpu核数+1
 * IO密集型    公式：cpu核数/1-阻塞系数        阻塞系数在0.8-0.9之间
 *             比如：8核CPU： 8/1-0.9=80个线程数
 * 
 * Runtime.getRuntime().availableProcessors()  得到CPU核数
 * 
　　自定义线程从池7个参数说明
　　核心线程数, 阻塞队列,最大线程数,拒绝策略, 其他线程空闲销毁时间,空闲时间单位,线程池工厂

 * 
 * @author wg
 *
 */
public class MyThreadPool {
    public static void main(String[] args) {
        System.out.println(Runtime.getRuntime().availableProcessors());
        
        
        
        ExecutorService threadPool = new ThreadPoolExecutor(
                2, 
                5, 
                1L, 
                TimeUnit.SECONDS, 
                new LinkedBlockingQueue<>(3), 
                Executors.defaultThreadFactory(),
//                new ThreadPoolExecutor.AbortPolicy()   超过极限8就报异常
//                new ThreadPoolExecutor.CallerRunsPolicy() //测试10 超过的处理不过来的回退到调用者
//                new ThreadPoolExecutor.DiscardOldestPolicy() //测试10  
                new ThreadPoolExecutor.DiscardPolicy()
                
                );
        

        try {
            //模拟10个用户来办理业务，每个用户就是一个来自外部的请求线程
            for (int i = 1; i <= 10; i++) {
                threadPool.execute(()->{
                      System.out.println(Thread.currentThread().getName()+"\t 办理业务");
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            threadPool.shutdown();
        }
    }

}