Java中创建多线程的三种方式 及其区别

 

1.什么是线程？区分进程与线程？

（1）线程：一个程序同时执行多个任务。通常，每一个任务就称为一个线程，线程是OS任务执行的基本单位；

（2）进程：操作系统中一个程序的执行周期称为一个进程，进程是资源分配的基本单位；

（3）线程与进程的区别：

     a） 线程比进程更轻量级，本质区别在于，每个进程拥有自己的一整套变量，而线程则是共享数据；

     b）撤销一个线程比启动一个进程开销要小的多，没有进程就没有线程，进程一旦终止，其内的线程也将不复存在；

2.线程的状态转换图：

3.创建多线程的方法：

  3.1 直接继承Thread类

   程序代码：

   

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 class TestThread {
    public static void main(String[] args) {
      Mythread mt1=new Mythread("thread1");
      Mythread mt2=new Mythread("thread2");
      Mythread mt3=new Mythread("thread3");

     new Thread(mt1).start();
     new Thread(mt2).start();
     new Thread(mt3).start();
    }
}

  运行结果：

  

  3.2 实现Runnable接口

class Mythread implements Runnable{
    private  String name;

    public Mythread(String name) {
        this.name = name;
    }

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

public class TestThread {
    public static void main(String[] args) {
      Mythread mt1=new Mythread("thread1");
      Mythread mt2=new Mythread("thread2");
      Mythread mt3=new Mythread("thread3");

     new Thread(mt1).start();
     new Thread(mt2).start();
     new Thread(mt3).start();
    }
}

运行结果截图：

3.3 实现Callable

从JDK1.5开始追加了新的开发包：Java.util.concurrent.这个开发包主要是进行高并发编程的，包含很多并发操作中的类。在这个包里边定义了一个新的接口Callable【以卖票为例】

程序代码：

class MyThreads implements Callable<String>{
    private  int ticket=10;//一共10张票


    @Override
    public String call() throws Exception {
        while(ticket>0){
            System.out.println("剩余票数："+this.ticket--);
        }
        return "票卖完了。";
    }
}

public class TestThread{
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        FutureTask<String > task=new FutureTask<>(new MyThreads());
        new Thread(task).start();
        new Thread(task).start();
        System.out.println(task.get());
    }
}

运行结果：

    3.4  三种方法的比较：

    （1）共同点：由以上例子可以得出，无论只用那种方式 来创建多线程，启动线程都是通过Thread类里边的 start（）方法来启动线程的。

    （2）由Thread类的定义可以得出，Thread类实现了Runnable接口，所以通过直接继承Thread类和实现Runnable接口来创建线程的时候，子类要覆写Runnable接口的 run()方法，而通过Callable接口创建线程要覆写它的  call（）方法；

         Thread类的定义和Runnable接口的定义：

      a)  Thread类的定义：

      b)   Runnabe接口的定义 

   c)  Callable接口的定义：

（3）Runnable接口的 run() 方法没有返回值，而Callable接口里的 call（）方法有返回值，所以在某些线程执行完成之后会带来返回结果的情况下，通过直线Callable接口创建线程会比较好。

（4）直接继承Thread类有单继承的局限，而使用Runnable接口可以规避这个问题，Runnable接口在多线程的处理上是用的是代理设计模式，并且使用Runnable实现的多新城的程序类可以更好的描述出出程序共享的概念。