java—多线程实现的三种方式

1. 继承Thread实现多线程
   
   （1）直接继承Thread类，覆写run（）方法。
   （2）覆写run（）方法之后，不能使用实例化对象直接调用。应该调用Thread类中的start()方法启动线程。
   public synchronized void start()此方法会自动调用线程的run()方法。
   （3）注意：每一个线程只能启动一次，若重复启动，会产生异常，但是是一个RuntimeException异常。
   举例如下：

package www.fanfan.com;

public class MyThread extends Thread{
    private String title;

    public MyThread(String title) {
        this.title = title;
    }
@Override
    public  void run(){
        for (int i = 0; i < 10; i++){
            System.out.println(this.title+":i="+i);
        }
    }

    public static void main(String[] args) {
        MyThread myThread = new MyThread("hello");
        MyThread myThread1 = new MyThread("world");
        myThread.start();
        myThread1.start();
    }
}

2. 实现Runnable接口实现多线程
   
   （1）Thread类的核心功能是进行线程的启动。
   如果一个类为了实现多线程直接去继承Thread类就会有但继承局限。
   在java中又提供有另外一种实现模式：Runnable接口。
   （2）但是Runnable接口中没有start（）方法来启动多线程，就需要调用Thread中的start（）方法。
   创建Thread的实例化对象调用start（）方法；
   通过Thread的构造方法实例化对象：Thread中的存在构造方法Thread（Runnable target）。
   （3）Runnable接口对象可以使用三种方式定义
   1）对象实例化
   2）匿名内部类
   3）Lambda表达式
   具体实现：
   （1）实例化定义接口对象并且启动线程

package www.fanfan.com;

class MyThread1 implements Runnable{
    private String title;

    public MyThread1(String title) {
        this.title = title;
    }

    @Override
    public void run() {
        for (int i = 0;i < 5;i++){
            System.out.println(this.title+":i="+i);
        }
    }
}

public class MyThread1Test {
    public static void main(String[] args) {
        MyThread1 myThread1 = new MyThread1("张三");
        MyThread1 myThread2 = new MyThread1("李四");
        new Thread(myThread1).start();
        new Thread(myThread2).start();
    }
}

（2）使用匿名内部类定义接口对象并且启动线程

public class MyThread1Test {
    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("使用匿名内部了定义接口对象");
            }
        }).start();
    }
}

（3）使用Lambda表达式定义接口对象

public class MyThread1Test {
    public static void main(String[] args) {
        Runnable runnable = ()-> System.out.println("这是一个lambda定义idea接口对象");
        new Thread(runnable);
    }
}

3. 使用Callable接口实现多线程
   
   （1）从JDK1.5开始追加了新的开发包：java.uti.concurrent。这个开发包主要是进行高并发编程使用的，包含很多在高
   并发操作中会使用的类。在这个包里定义有一个新的接口Callable.。

（2）线程执行结束后需要返回一些结果——此时需要使用Callable接口实现多线程。
具体使用：

package www.fanfan.com;

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

class MyThread4 implements Callable{

    private int ticket = 10;
    @Override
    public String call() throws Exception {
        while (ticket > 0){
            System.out.println("剩余的票数："+ticket--);
        }
        return "对不起，没有多余的票了";
    }
}
public class MyThreadTest4 {
    public static void main(String[] args) {
        FutureTask task = new FutureTask(new MyThread4());
        new Thread(task).start();
        new Thread(task).start();
        try {
            System.out.println(task.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}