实现多线程的方式

Thread的构造方法

//分配一个新的 Thread对象。
Thread()

//分配一个新的 Thread对象。
Thread(Runnable target)

//分配一个新的 Thread对象。
Thread(Runnable target, String name)

//分配一个新的 Thread对象。
Thread(String name)

//分配一个新的 Thread对象。
Thread(ThreadGroup group, Runnable target)

//分配一个新的 Thread对象，使其具有 target作为其运行对象，具有指定的 name作为其名称，属于 group引用的线程组。
Thread(ThreadGroup group, Runnable target, String name)

//分配一个新的 Thread对象，以便它具有 target作为其运行对象，将指定的 name正如其名，以及属于该线程组由称作 group ，并具有指定的 堆栈大小 。
Thread(ThreadGroup group, Runnable target, String name, long stackSize)

//分配一个新的 Thread对象。
Thread(ThreadGroup group, String name)

其中最常用的是空参的构造和传入一个runnable接口这种方式。需要注意的是Thread也实现了Runnable接口，所以也可以传入一个Thread类的对象。

继承Thread类方式

public class Mythread extends Thread{
    @Override
    public void run() {
        super.run();
        System.out.println("myThread");
    }
}

public class TestThread {
    public static void main(String[] args) {
        Mythread mythread=new Mythread();
        mythread.start();
    }
}

实现Runable接口

public class MyRunnable implements Runnable{
    @Override
    public void run() {
        System.out.println("myRunnable");
    }
}
public class TestThread {
    public static void main(String[] args) {
        Thread thread=new Thread(new MyRunnable());
        thread.start();
    }
}

使用Callable和Future创建线程

具体是创建Callable接口的实现类，并实现call方法，并且使用FutureTask类来包装Callable实现类的对象，最后把FutureTask对象作为Thread的target来创建线程，如下：

public class MyCallable implements Callable {
    @Override
    public Object call() throws Exception {
        System.out.println("myCallable");
        return "hello callable";
    }
}
public class TestThread {

    public static void main(String[] args) {
        Callable callable=new MyCallable();
        FutureTask futureTask=new FutureTask(callable);
        Thread thread=new Thread(futureTask);
        thread.start();

        try {
            Object object = futureTask.get();	//获取call方法的返回值
            System.out.println(object);	//hello callable
        }catch (Exception e) {
            e.printStackTrace();
        }
    }
}

以上就是实现多线程的三种方式。
第三种方式之所以可以，是因为FutureTask实现了Runnable接口而已。

多线程的常用方法

currentThread()

可以返回代码段正在被哪个线程调用的信息，如下：

public class Mythread extends Thread{

 	public Mythread(){
        System.out.println("构造："+Thread.currentThread().getName());	//构造：main
    }
    @Override
    public void run() {
        super.run();
        System.out.println(Thread.currentThread().getName());		//Thread-0
    }
	/**
	从运行结果可以看出，Mythread类的构造方法是被main线程调用的，而run方法是被Thread-0线程调用的，run方式是自动调用的方法
	*/
}
public class TestThread {

    public static void main(String[] args) {
        Mythread mythread=new Mythread();
        mythread.start();
        System.out.println(Thread.currentThread().getName());		//main
    }
}

标签：Runnable,java,String,Thread,基础知识,Mythread,多线程,public,target
来源： https://www.cnblogs.com/bill-g-chen/p/15700089.html