标签：多线程概念 system shu art time 实现 等于 相同 并且
在前面一篇介绍了线程的生命周期【并发编程之多线程概念 】，在本篇将正式介绍如何创建、中断线程，以及线程是如何销毁的。最后，我们会讲解一些常见的线程API。
线程创建
Java 5 以前，实现线程有两种方式：扩展java.lang.Thread类，实现java.lang.Runnable接口。这两种方式都是都是直接创建线程，而每次new Thread都会消耗比较大的资源，导致每次新建对象时性能差；而且线程缺乏统一管理，可能无限制新建线程，相互之间竞争，很可能占用过多系统资源导致死机或OOM。同时，new Thread的线程缺乏更多功能，如定时执行、定期执行、线程中断。
Java 5开始，JDK提供了4中线程池（newFixedThreadPool、newCachedThreadPool、newScheduledThreadPool、newSingleThreadExecutor）来获取线程。这样做的好处是：可以重用已经存在的线程，减少对象创建、消亡的开销，性能佳；而且线程池可有效控制最大并发线程数，提高系统资源的使用率，同时避免过多资源竞争，避免堵塞。通过特定的线程池也可以实现定时执行、定期执行、单线程、并发数控制等功能。
创建线程的代码实现
//1.自定义一个类继承Thread类 public class ExThread extends Thread { //2.重写run() @Override public void run() { for (int i = 0; i < 100; i++) { System.out.println(Thread.currentThread().getName()+”:”+i); } } public static void main(String[] args) { //3.创建Thread子类对象 ExThread exThread = new ExThread(); //4.调用start方法启动自定义线程 exThread.start(); } }
//1.自定义一个类实现Runnable接口 public class ImThread implements Runnable{ //2.实现run() @Override public void run() { for (int i = 0; i < 100; i++) { System.out.println(Thread.currentThread().getName()+”:”+i); } } public static void main(String[] args) { //3.创建Runnable实现类对象 ImThread imThread = new ImThread(); //4.创建Thread对象 Thread thread = new Thread(imThread); //5.调用start()开启线程 thread.start(); } }
创建一个固定线程数的线程池，可控制线程最大并发数，超出的线程会在队列中等待
import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class CreateThreadByFixedPool { /** * Cover Runnable.run() */ private static void run(){ System.out.println(Thread.currentThread().getName()+" is running..."); try { Thread.sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); } } public static void main(String[] args) { ExecutorService pool = Executors.newFixedThreadPool(3); for (int i = 0; i < 10; i++) { pool.execute(CreateThreadByFixedPool::run); } } }
创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程.
线程池的容量为无限大，当执行第二个任务时第一个任务已经完成，会复用执行第一个任务的线程，而不用每次新建线程。
import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class CreateThreadByCachedPool { public static void main(String[] args) { ExecutorService pool = Executors.newCachedThreadPool(); for (int i = 0; i < 10; i++) { try { Thread.sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); } pool.execute(() -> System.out.println(Thread.currentThread().getName()+" is running...")); } } }
创建一个固定线程数的线程池，支持定时及周期性任务执行。
import java.util.concurrent.Executors; import java.util.concurrent.ScheduledExecutorService; import java.util.concurrent.TimeUnit; public class CreateThreadByScheduledPool { public static void main(String[] args) { ScheduledExecutorService pool = Executors.newScheduledThreadPool(3);
//delay 2s excute. pool.schedule(() -> System.out.println(Thread.currentThread().getName()+" delays 2s "), 2, TimeUnit.SECONDS);
//delay 2s and every 3s excute. pool.scheduleAtFixedRate(() -> System.out.println(Thread.currentThread().getName()+" delays 2s every 3s execte"), 2, 3, TimeUnit.SECONDS); } }
创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。
public class CreateThreadBySingleThreadPool { public static void main(String[] args) { ExecutorService pool = Executors.newSingleThreadExecutor(); for (int i = 0; i < 10; i++) { final int index = i; pool.execute(() ->{ System.out.println(String.format("The thread %d (%s) is running...", index,Thread.currentThread().getName())); try { Thread.sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); } }); } } }
Thread负责线程本身相关的职责和控制，Runnable负责逻辑业务。
线程中断
线程销毁
public static void main(String[] args) throws InterruptedException { Thread t = new Thread(){ @Override public void run() { System.out.println("I will start work."); while(!isInterrupted()){ System.out.println("working...."); } System.out.println("I will exit."); } }; t.start(); TimeUnit.MICROSECONDS.sleep(100); System.out.println("System will exit."); t.interrupt(); }
public class FlagThreadExit { static class MyTask extends Thread{ private volatile boolean closed = false; @Override public void run() { System.out.println("I will start work."); while(!closed && !isInterrupted()){ System.out.println("working...."); } System.out.println("I will exit."); } public void closed(){ this.closed = true; this.interrupt(); } } public static void main(String[] args) throws InterruptedException { MyTask task = new MyTask(); task.start(); TimeUnit.MICROSECONDS.sleep(100); System.out.println("System will exit."); task.closed(); } }
多线程API
|
方法
|
返回值
|
作用
|
|
|
yield()
|
static void
|
暂停当前正在执行的线程对象，并执行其他线程。
|
只有优先级大于等于该线程优先级的线程（包括该线程）才有机会被执行
释放CPU资源，不会放弃monitor锁
|
|
sleep()
|
static void
|
使当前线程休眠，其它任意线程都有执行的机会
|
释放CPU资源，不会放弃monitor锁
|
|
wait()
|
void
|
使当前线程等待
|
Object的方法
|
|
interrupt()
|
void
|
中断线程
|
可中断方法
|
|
interrupted()
|
static boolean
|
判断当前线程是否中断
|
|
|
isInterrupted()
|
boolean
|
测试线程是否已经中断
|
|
|
join()
|
void
|
在线程A内，join线程B，线程A会进入BLOCKED状态，直到线程B结束生命周期或者线程A的BLOCKED状态被另外的线程中断
|
可中断方法
|
wait使用
public class WaitDemo { public static void main(String[] args) { ExecutorService pool = Executors.newFixedThreadPool(2); pool.execute(() -> { synchronized (WaitDemo.class){ System.out.println("Enter Thread1..."); System.out.println(Thread.currentThread().getName()+" is waiting..."); try { WaitDemo.class.wait(); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("Thread1 is going..."); System.out.println("Shut down Thread1."); } }); try { Thread.sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); } pool.execute(() ->{ synchronized (WaitDemo.class) { System.out.println("Enter Thread2..."); System.out.println(Thread.currentThread().getName()+" is notifying other thread..."); WaitDemo.class.notify(); try { Thread.sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("Thread2 is going..."); System.out.println("Shut down Thread2."); } }); } }
补充
标签：多线程概念 system shu art time 实现 等于 相同 并且
原文地址：https://www.cnblogs.com/BlueStarWei/p/11497198.html
