java线程实现方式，

java线程实现方式，

java线程实现方式

首先，单线程理解为一个人，多线程可以理解为多个人，一般情况下，一项任务分配给多个人要比分配给一个人花费的时间短。所以java的多线程就是为了工作起来更快更省时间。

java线程创建的两种方式

继承Thread类

启动线程的唯一方法就是通过Thread类的start()实例方法，start()方法是一个native方法，它将启动一个新线程，并执行run()方法

如下代码

package com.rookie.bigdata.thread;


/**

 * @author rookie

 * @version 1.0

 * @date 2020/3/19 21:16
   */
   public class MyThread extends Thread {

   private String name;

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

   @Override
   public void run() {
       for (int i = 0; i < 100; i++) {
           System.out.println("执行 " + i + name);
           try {
               Thread.sleep(100);
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
       }
   }

   public static void main(String[] args) {
       MyThread thread1 = new MyThread("thread1");
       thread1.start();

       MyThread thread2 = new MyThread("thread2");
       thread2.start();

   }

}

实现Runnable接口

另一种方式就是实现Runnable接口

package com.rookie.bigdata.thread;

/**

 * @author rookie

 * @version 1.0

 * @date 2020/3/19 21:23
   */
   public class MyRunnable implements Runnable {

   private String name;

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

   @Override
   public void run() {
       for (int i = 0; i < 100; i++) {
           System.out.println("执行 " + i + name);
           try {
               Thread.sleep(100);
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
       }
   }

   public static void main(String[] args) {
       MyRunnable runnable1 = new MyRunnable("runnable1");
       Thread thread1 = new Thread(runnable1);
       thread1.start();

       MyRunnable runnable2 = new MyRunnable("runnable2");
       Thread thread2 = new Thread(runnable2);
       thread2.start();


    }

}

实现Callable接口

实现Callable接口功能要比上面两种类型更强大，如下

package com.rookie.bigdata.thread;

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

/**

 * @author rookie

 * @version 1.0

 * @date 2020/3/19 21:56
   */
   public class MyCallable implements Callable {
   private String name;

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

   @Override
   public Object call() throws Exception {
       for (int i = 0; i < 100; i++) {
           System.out.println("执行 线程" + i + name);
           try {
               Thread.sleep(100);
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
       }
       return "task";
   }

   public static void main(String[] args) throws ExecutionException, InterruptedException {
       MyCallable myCallable=new MyCallable("callabe");
       FutureTask futureTask=new FutureTask(myCallable);
       Thread thread=new Thread(futureTask);
       thread.start();

       System.out.println(futureTask.get());
       System.out.println("执行主线程");

   }

}

采用实现Callable接口的方式时，如果在启动线程中调用futureTask.get()方法时，启动线程就会等待调用的线程执行完毕以后，启动线程才会往下执行其他的流程。

线程的生命周期

当线程没创建启动以后，它既不是启动就马上进入了执行状态，也不是一直处于执行状态。在线程的生命周期中，它需要经过新建(New)、就绪(Runnable)、运行(Running)、阻塞（Blocked）和死亡(Dead) 5种状态。尤其当线程启动以后，不是一直占用CPU运行，CPU是在多条线程之间切换，于是线程状态也会多次在运行、阻塞之间切换

新建(New)

当程序使用new创建一个线程之后，该线程就处于新建状态，

就绪状态(Runnable)

当线程对象调用了start()方法之后，该线程处于就绪状态。

运行状态(Running)

如果处于就绪状态的线程获得了CPU,开始执行run()方法的线程执行体，则该线程处于运行状态。

阻塞状态(Blocked)

阻塞状态是指线程因为某种原因放弃了CPU使用权，也即让出了CPU timeslice,暂时停止运行。直到线程进入可运行状态，才有机会再次获取CPU timeslice转到运行状态。阻塞分下面三种情况：

1、等待阻塞(o.wait->等待队列):运行的线程执行o.wait()方法，JVM会把该线程放入等待队列中

2、同步阻塞(lock)：运行的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM会把该线程放入锁池(lock pool)中。

3、其他阻塞(sleep/join):运行的线程执行sleep或join方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。当sleep()状态超时、join()等待线程或者超时、或者I/O处理完毕时，线程重新转入可运行状态。

线程死亡(Dead)

线程死亡主要包括下面三种方式：

1、正常结束：run()或call()方法执行完成，线程正常结束。

2、异常结束：线程抛出异常Exception或者Error。

3、调用stop:直接调用该线程的stop()方法来结束该线程。

相关源码参考： https://github.com/albert-liu435/rookies-javases/tree/master/rookie-javase-thread