多线程实现 入门

多线程的实现方案一：继承Thread类

1.定义一个子类MyThread继承线程类java.lang.Thread，

2.重写run()方法 创建MyThread类的对象

3.调用线程对象的start()方法启动线程（启动后还是执行run方法的）

public class ThreadDemo1 {
    public static void main(String[] args) {
        //3. new一个新线程对象
        Thread t = new MyThread();
        //4. 调用start方法启动线程(执行的方法还是run)
        t.start();//以线程的方式

        for (int i = 0; i < 5; i++){
            System.out.println("主线程执行输出" +i);
        }
    }
}
/*
    1.定义一个线程类继承Thread类
 */
class MyThread extends Thread{
    /*
     2. 重写run方法, 里面是定义线程以后要干啥
     */
    @Override
    public void run() {
        for (int i = 0; i < 5 ; i++){
            System.out.println("子线程执行输出"+i);
        }
    }
}
-------------------------------------------

多线程的实现方案二：实现Runnable接口

1.定义一个线程任务类MyRunnable实现Runnable接口，

2.重写run()方法 创建MyRunnable任务对象

3.把MyRunnable任务对象交给Thread处理。

4.调用线程对象的start()方法启动线程

public class ThreadDemo1 {
    public static void main(String[] args) {
        //3. 创建一个任务对象
        Runnable target = new MyThread();
        //4. 把任务对象交给Thread处理
        Thread t = new Thread(target);
        //5. 启动线程
        t.start();

        for (int i = 0; i < 10; i++){
            System.out.println("主线程执行输出 " +i);
        }
    }
}
/*
    1.定义一个线程任务类实现Runnable接口
 */
class MyThread implements Runnable{
    /*
     2. 重写run方法, 定义线程的执行任务的
     */
    @Override
    public void run() {
        for (int i = 0; i < 10 ; i++){
            System.out.println("子线程执行输出 "+i);
        }
    }
}
方式二优缺点

优点：线程任务类只是实现接口，可以继续继承类和实现接口，扩展性强。

缺点：编程多一层对象包装，如果线程有执行结果是不可以直接返回的。

第二种方法拓展: 使用匿名内部类简化

------------------------------------------

第三种利用Callable、FutureTask接口实现

得到任务对象 定义类实现Callable接口，重写call方法，封装要做的事情。用FutureTask把Callable对象封装成线程任务对象。

、把线程任务对象交给Thread处理。

、调用Thread的start方法启动线程，执行任务

、线程执行完毕后、通过FutureTask的get方法去获取任务执行的结果。

 

public class ThreadDemo1 {
    public static void main(String[] args) {
        //3. 创建Callable任务对象
        Callable<String> call = new MyCallable(10);
        //4. 把Callable任务对象, 交给FutureTask对象
        //   FutureTask对象的作用 1: 是Runnable的对象(实现了Runnable接口), 可以交给Thread了
        //   FutureTask对象的作用 2: 可以在线程执行完毕之后通过调用其get方法得到线程执行完成的结果
        FutureTask<String> f1 = new FutureTask<>(call);
        //5. 交给线程处理
        Thread t1 = new Thread(f1);
        //6. 启动线程
        t1.start();

        Callable<String> call2 = new MyCallable(20);
        FutureTask<String> f2 = new FutureTask<>(call2);
        Thread t2 = new Thread(f2);
        t2.start();

        try {
            f1.get();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
class MyCallable implements Callable<String>{
    private int n;
    public MyCallable(int n) {
        this.n = n;
    }

    @Override
    public String call() throws Exception {
        int sum = 0;
        for (int i = 1; i<=n; i++){
            sum += i;
        }
        return "最终结果"+sum;
    }
}

标签：入门,Thread,实现,对象,线程,FutureTask,new,多线程,public
来源： https://www.cnblogs.com/LZYBOK/p/16076473.html