创建线程方式

目录

线程：一个顺序单一执行流程就是一个线程，代码有先后顺序的执行

1、继承线程Thread类创建线程

2、实现Runnable接口

3、实现Callable接口

4、线程池创建线程

---

线程：一个顺序单一执行流程就是一个线程，代码有先后顺序的执行

多线程：多个单一顺序的的流程并发运行，造成视觉上同时运行的效果

并发运行：多线程时线程调度会根据CPU 运行时间划分为若干个时间片段，尽可能地均匀分配每个线程的时间片，当时间超时后会将时间再次分配给另一个线程，由于CPU执行时间微小，我们看不到，所以我们感觉多个线程是一起执行的，这种情况叫做并发运行

继承线程Thread类创建线程

定义一个类，让类继承线程类，重写线程里的run方法，并在run方法中定义要执行的线程任务

class Thread2 extends Thread{
    @Override
    public void run() {

        for (int i = 0; i <1000 ; i++) {
            System.out.println("hh");
        }
    }
}

创建此类的上转型对象，调用start方法，使线程进入就绪状态，等待CPU分配时间片执行线程任务

缺点：
1、直接继承thread类，会导致其不能再继承其他的类去复用方法，这在实际开发中是非常不方便的
2、定义线程的同时重写了run方法，会导致线程与线程任务绑定在一起，不利于线程的重用

2、实现Runnable接口

让一个类实现runnable接口。重写run方法

class MyRunnable implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println("10");
        }
    }
}

 创建线程对象，线程类中的构造方法有参数为Runnable类型的参数

所以我们可以把此类的上转型对象放到线程对象的实参入口，在调用start方法，让线程运行

//创建线程任务
        Runnable r1=new MyRunnable();
        Runnable r2=new MyRunnable1();

        //创建线程来分别执行任务
        Thread t1=new Thread(r1);
        Thread t2=new Thread(r2);
        t1.start();t2.start();

缺点：重写run方法时没有返回值，方法内部如果出现异常也不能及时处理

优点：接口可以多实现，更灵活，而且线程之间是分离的，复用性更好

3、实现Callable接口

重写call方法创建线程任务，该接口是jdk5提供的因为thread线程类中没有callable类型参数的构造方法，所以，我们通常搭配FutureTask类一起使用，代码如下

class MyCallable implements Callable{
    @Override
    public Object call() throws Exception {
        for (int i = 0; i < 1000; i++) {
            System.out.println("去");
        }
        return "macallable";
    }
}
//创建线程执行任务
        Callable c1=new MyCallable();
        Callable c2=new MyCallable2();
        //创建futuretask类的实例
    /*
    链接线程与线程任务callable，获取call方法的返回值
     */
        FutureTask f1=new FutureTask(c1);
        FutureTask f2=new FutureTask(c2);
        //创建线程执行任务
        Thread t1=new Thread(f1);
        Thread t2=new Thread(f2);
        //启动线程
        t1.start();t2.start();
        /*
        使用futuretask对象的get方法可以获取对应
        线程任务的返回值
         */

4、线程池创建线程

线程池：创建线程的第四种方式

线程池是一种管理线程的机制，主要有两个作用：

1、控制线程数量   2、重用线程

//创建固定的线程池大小（线程池中的线程数量设置为1）

Executorservice threadPool=Executors.new FixedThreadPool(1)

threadPool.execute(new FutureTask(new Callable() {
    @Override
    public Object call() throws Exception {
        for (int i = 0; i < 10; i++) {
            System.out.println(50);
        }
        return Thread.currentThread();
    }
}));
//创建5个线程任务
for (int i = 0; i < 5; i++) {
    Runnable r=new Runnable() {
        @Override
        public void run() {
            Thread t=Thread.currentThread();
            System.out.println(t.toString());
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(t+"执行任务完毕");
        }
    };
    /*
    void execute(Runnable command);
    将线程任务交给线程池执行
     */
    threadPool.execute(r);

这里可以看到，创建了一个线程，通过线程池对象调用execute方法将指定线程任务交给线程池执行