Thread多线程之启动线程的三种方法

方法一:继承Thread

1.自定义一个类,用来继承Thread类

2.在自定义类中重写run()方法

3.在测试类中创建自定义类对象

4.启动线程

package com.thread.demo;


/*多线程实现方法一*/
public class MyThread1 {

    public static void main(String[] args) {
        MyThreadRun myThread=new MyThreadRun();
        MyThreadRun myThread1=new MyThreadRun("run方法实现2");
        //设置线程名
        //myThread.setName("run方法实现1");
        myThread.run();
        myThread1.run();
        
        myThread.start();

        //Thread.currentThread() 获取当前正在执行线程的对象,
        //Thread.currentThread().setName("主线程") 获取当前正在执行线程的对象,并设置线程名
        Thread.currentThread().setName("主线程");
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }

}

class MyThreadRun extends Thread{
    public MyThreadRun(){

    }
    public MyThreadRun(String name){
        super(name);
    }

    //run方法是每个线程运行过程中都必须执行的方法
    @Override
    public void run() {
        super.run();
        for (int i = 0; i < 10; i++) {
            System.out.println(this.getName()+":"+i);
        }

    }
}

run()方法是每个线程运行过程中都必须执行的方法.

start()方法的作用是:启动一个分支线程,在JVM中开辟一个新的栈空间,这段代码任务完成之后,瞬间就结束了,线程就启动成功了. 

启动成功的线程会自动调用run()方法,并且run()方法在分支栈的栈底部(压栈).

run()方法在分支栈的栈底部,main方法在主站的栈底部,run和main是平级的.

方法二.实现接口Runnable

1.自定义一个类来实现Runnable接口

2.在自定义类中重写run()方法

3.创建Thread对象,并把自定义类对象当做Thread类构造方法的参数传递进去

4.启动线程

package com.thread.demo;


/*多线程实现方法二*/
public class MyThread2 {

    public static void main(String[] args) {
        //可直接通过lambda表达式直接表达,调用Thread有参构造方法,第一个参数是Runnable类型参数,第二个是线程名
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println(Thread.currentThread().getName() + ":" + i);
                }
            }
        },"线程3").start();

        //创建一个类通过继承Runnable接口实现调用线程,该接口必须要实现run()方法.
        MyThreadRunnable myThreadRunnable = new MyThreadRunnable();
        Thread t = new Thread(myThreadRunnable, "线程");
        Thread thread1 = new Thread(myThreadRunnable, "线程1");
        Thread thread2 = new Thread(myThreadRunnable, "线程2");
        t.start();
        thread1.start();
        thread2.start();
    }



}

//自定义线程类,实现Runnable接口
//这并不是一个线程类,是一个可运行的类,它还不是一个线程
class MyThreadRunnable implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);
        }

    }
}

方法三:实现Callable接口

1.自定义一个类来实现Callable接口

2.在自定义类中重写call()方法

3.创建FutureTask,Thread对象,并把自定义对象作为FutureTask类构造方法的参数传递进去,把FutureTask对象传递给Thread对象

4.启动线程

package com.thread.demo;


import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

/*多线程实现方法三*/
public class MyThread3 {

    public static void main(String[] args) throws Exception {

        //一种方法
        Callable myCallable=new MyCallable();
        FutureTask futureTask = new FutureTask(myCallable);

        //二种方法
        //第一步:创建一个未来任务类对象
        //参数非常重要,需要给一个Callable接口实现类对象
        FutureTask futureTask1 = new FutureTask(new Callable() {
            //call()方法相当于run方法,只不多有个返回值
            @Override
            public Object call() throws Exception {
                //线程执行一个任务,执行之后可能会有一个执行结果
                //模拟执行
                System.out.println("call begin");
                Thread.sleep(1000 * 10);
                System.out.println("call end");
                int a = 1;
                int b = 2;
                return a + b;//自动装箱
            }
        });

        //创建线程对象
        Thread thread = new Thread(futureTask);
        Thread thread1 = new Thread(futureTask1);
        //启动线程
        thread.start();
        thread1.start();

        //这里是main方法,这是在主线程中
        // 在主线程中,怎么获取thread线程的返回结果
        //使用get()方法执行会导致"当前线程阻塞
        Object o = futureTask.get();
        Object o1 = futureTask1.get();
        //main方法这里的程序想要执行必须等待get()方法的结束,而get()方法可能需要很久,因为get()方法是为了那另一个线程的执行结果(call()),另一个线程执行需要时间
        System.out.println(o);
        System.out.println(o1);
    }


}

class MyCallable implements Callable{
    @Override
    public Object call() throws Exception {
        //线程执行一个任务,执行之后可能会有一个执行结果
        //模拟执行
        System.out.println("call begin");
        Thread.sleep(1000 * 10);
        System.out.println("call end");
        int a = 100;
        int b = 200;
        return a + b;//自动装箱

    }
}

转载:java多线程（超详细）_Mr.乐.的博客-优快云博客_java多线程