2019.12.24 java多线程

java实现多线程通常通过3种方法来实现：

方法一：

　　继承Thread，覆写(重写)run()方法，通过调用start()方法启动线程，有一定的局限，只能继承这么一个类，不能继承别的类了

创建MyThread继承Thread

package com.lzw;

public class MyThread extends Thread{
    //通过继承Thread类来实现多线性

    public MyThread(String name){
        //线程的名字
        super(name);
    }
    //重写run()方法
    public void run(){
        int i = 0;
        while(i++ < 10){
            System.out.println(Thread.currentThread().getName());
        }
    }
}

创建一个Test2类来new线程

package com.lzw;

public class Test2 {

    public static void main(String[] args){
        //创建多线程实例
        MyThread thread1 = new MyThread("1号");
        MyThread thread2 = new MyThread("2号");
        //启动多线程
        thread1.start();
        thread2.start();
    }
}

方法二：

　　实现Runnable接口，同时重写接口中的run()方法，

　　创建实现类，

　　使用Thread有参构造方法创建多线程，

　　调用start()方法启动线程

创建MyThread实现Runnable接口实现类

package com.lzw;

public class MyThread implements Runnable{
    //通过实现Runnable接口来实现多线性

    //重写run()方法
    public void run(){
        int i = 0;
        while(i++ < 10){
            System.out.println(Thread.currentThread().getName());
        }
    }
}

创建一个Test2类来new线程

package com.lzw;

public class Test2 {

    public static void main(String[] args){
        //创建Runnable接口实现类实例对象
        MyThread myThread = new MyThread();
        //创建线程对象，下面两个地方用的是同一个myThread
        Thread thread1 = new Thread(myThread, "1");
        thread1.start();
        Thread thread2 = new Thread(myThread, "2");
        thread2.start();
        int i = 0;
        while(i++ < 5){
            System.out.println("3");
        }
    }
}

方法三：

　　实现Callable接口方法，这种方法还有返回值，

　　创建一个Callable接口的实现类，同时重写call()方法，

　　new一个实现类，

　　通过FutureTask线程结果处理类来封装实现类，

　　使用Thread有参构造方法，创建线程

　　调用start()方法启动线程

创建MyThread实现Callable接口实现类

package com.lzw;

import java.util.concurrent.Callable;

public class MyThread implements Callable<Object> {
    //通过实现Callable接口来实现多线程
    //重写call()方法
    @Override
    public Object call() throws Exception {
        int i = 0;
        while(i++ < 1000){
            System.out.println(Thread.currentThread().getName());
        }
        return i;
    }
}

创建Test2来展示创建线程

package com.lzw;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class Test2 {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //创建Callable接口实现类
        MyThread myThread = new MyThread();
        //使用FutureTask封装Callable接口
        FutureTask<Object> f1 = new FutureTask<>(myThread);
        //使用Thread有参构造方法，实现多线程
        Thread thread1 = new Thread(f1, "1");
        //启动多线程
        thread1.start();
        //创建另外一个多线程
        FutureTask<Object> f2 = new FutureTask<>(myThread);
        Thread thread2 = new Thread(f2, "2");
        thread2.start();

        //输出结果
        System.out.println(f1.get());//1001
        System.out.println(f2.get());//1001
    }
}