java创建线程的方式

Java创建线程的方法有如下3种。

1）继承Thread类创建线程 extends Thread
2）实现Runnable接口创建线程 implements Runnable
3）实现Callable接口和Future创建线程 implements Callable
他们之间的关系如下：

继承Thread类创建线程

public class MyThread extends Thread {

	public MyThread() {
		super("MyThread");
	}

	@Override
	public void run() {
		long sum=0;
		for(int i=0;i<1999999999l;i++){
			sum+=i;
		}

		System.out.println(sum);
	}
}

启动线程，即调用线程的start()或者run()方法

public class Text{
	
	public static void main(String[] args) {
	
		  //第一种方式启动线程
		  MyThread my=new MyThread();
		  my.start();

		  //第二种方式启动线程
		  new Thread(my).start();
	}
 
}

实现Runnable接口创建线程

public class MyThread2 implements Runnable {

	private int ticket = 10;

	public MyThread2() {
		Thread.currentThread().setName("售票线程");
	}

	/**
	 * 模仿售票服务
	 */
	@Override
	public void run() {

		while (true) {
			if (ticket > 0) {
				try {
					Thread.sleep(10);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}

				System.out.println(Thread.currentThread().getName() + "is saling...." + ticket--);
			}
		}
	}
}

启动线程：执行start()或者run()方法

public class Text02 {

		public static void main(String[] args) {
			
			/*MyThread2 tt=new MyThread2();
			
			//启动三个线程
			new Thread(tt).start();
			new Thread(tt).start();
			new Thread(tt).start();*/

			new MyThread2().run();
            new MyThread2().run();
            new MyThread2().run();
			
		}
}

实现Callable接口和Future创建线程

public class MyThread3 implements Callable {

    //可以作为入参的接口
    public MyThread3(){
        Thread.currentThread().setName("MyThread3");
    }
    /**
     * 特点：1.具有返回值 2.可以抛出异常
     * @return
     * @throws Exception
     */
    @Override
    public String call() throws Exception {

        return "true";
    }
}

启动：java使用FutureTask类来包装Callable对象，该FutureTask对象封装了Callable对象的call()方法的返回值。调用FutureTask对象的get()方法来获得子线程执行结束后的返回值。

public class Text03 {

    public static void main(String[] args) {

        MyThread3 myThread3=new MyThread3();

        //执行 Callable 方式，需要 FutureTask 实现类的支持，用于接收运算结果
        FutureTask future = new FutureTask<>(myThread3);

        //启动线程
        new Thread(future).start();

        try {
            String result = future.get();
            System.out.println("结果是--"+result);

        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

总结区别

1、线程只是实现Runnable或实现Callable接口，还可以继承其他类。如果继承Thread类的线程类不能再继承其他父类（Java单继承决定）。注：一般推荐采用实现接口的方式来创建多线程。

2、实现Runnable和实现Callable接口的方式基本相同，不过是后者执行call()方法有返回值，后者线程执行体run()方法无返回值。

转载于:https://www.cnblogs.com/codingdong/p/10252309.html