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()方法来结束该线程。