多线程(2)

创建线程的三种方式

1.继承java.lang.Thread

public class Thread01 extends Thread{//继承Thread类

    @Override
    public void run() {//重写Thread的run()方法
        System.out.println("do something!");
    }
}

public class ThreadMain {

    public static void main(String[] args) {
        Thread01 t1 = new Thread01();
        t1.start();//使用Thread的start方法新建线程
    }
}

start()_方法和run方法的区别：

1>.start是类Thread的一个方法

2>.run是接口Runnable的一个抽象方法，使用它需要实现

3>.start是新建一个线程，run不会新建线程，它是顺序执行的

2.实现java.lang.Runnable接口

public class RunnableImpl implements Runnable{//实现Runnable接口

    public void run() {//实现Runnable中的run()方法
        System.out.println("do something 2.");
    }

}

public class RunnableMain {

    public static void main(String[] args) {
        RunnableImpl r = new RunnableImpl();
        Thread t = new Thread(r);
        t.start();//启动
    }

}

Thread类和Runable接口的区别：

1>.类和接口的区别，单继承和实现接口，接口可扩展性强

2>.Runnable可以处理同一共享资源

3>.实现Runnable接口的类可以放入线程池中

3.实现java.util.concurrent.Callable接口

public class CallableImpl implements Callable{//实现Callable接口

    public Object call() throws Exception {//实现Callable接口的call()方法
        String hi = "你好";
        return hi;//有返回值
    }

}

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class CallableMain {

    @SuppressWarnings("unchecked")
    public static void main(String[] args) {
        Callable c = new CallableImpl();//产生结果
        //创建线程池对象
        ExecutorService pool = Executors.newSingleThreadExecutor();  
        Future future = pool.submit(c);//拿到结果
        try {
            Object returnMsg = future.get();//get()获取返回结果
            System.out.println(returnMsg.toString());
            //你好
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

Callable接口的优势：

1.有返回接口

2.有Future对象，操作更方便

3.可以抛异常