1. 首页
  2. 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()方法来结束该线程。

java线程实现方式

本文来自投稿,不代表程序员编程网立场,如若转载,请注明出处:http://www.cxybcw.com/188552.html

联系我们

13687733322

在线咨询:点击这里给我发消息

邮件:1877088071@qq.com

工作时间:周一至周五,9:30-18:30,节假日休息

QR code