线程的创建和使用
Java语言的JVM允许程序运行多个线程，它通过java.lang.Thread类来体现
JDK1.5之前创建新执行线程有两种方法
- 继承 Thread 类的方式
-
方式一：继承 Thread 类
步骤
定义子类继承 Thread 类
- 子类中重写 Thread 类中的 run方法
- 创建 Thread 子类对象，即线程对象
- 调用线程对象 start 方法：启动线程，运行 run 方法
注意
- 如果自己手动调用 run()方法，那么就只是普通方法，没有启动多线程模式
- run()方法由 JVM 调用，什么时候调用，执行的过程控制都有操作系统的CPU调度决定
- 想要启动多线程，必须调用start方法
一个线程对象只能调用一次 start()方法启动，如果重复调用则将抛出异常IllegalThreadStateException ```java // 1.创建一个继承于Thread类的子类 class MyThread extends Thread {
// 2.重写Thread类的run() @Override public void run() {
for (int i = 0; i < 100; i++) {if(i % 2 == 0)System.out.println(Thread.currentThread().getName() + ":" + i);}
} }
public class ThreadTest { public static void main(String[] args) { // 3.创建Thread类的子类的对象 MyThread t = new MyThread();
// 4.通过此对象调用start():①启动当前线程 ② 调用当前线程的run()t.start();//问题一：我们不能通过直接调用run()的方式启动线程。// t.run();//问题二：再启动一个线程，遍历100以内的偶数。//不可以还让已经start()的线程去执行。会报IllegalThreadStateException// t.start();//我们需要重新创建一个线程的对象new MyThread().start();//如下操作仍然是在main线程中执行的。for (int i = 0; i < 100; i++) {if(i % 2 == 0)System.out.println(Thread.currentThread().getName() + ":" + i + "-main");}}
}
<br />练习：创建两个分线程，其中一个线程遍历100以内的偶数，另一个线程遍历100以内的奇数```javapublic class ThreadDemo {public static void main(String[] args) {//创建Thread类的匿名子类的方式new Thread(){@Overridepublic void run() {for (int i = 0; i < 100; i++) {if(i % 2 == 0)System.out.println(Thread.currentThread().getName() + ":" + i);}}}.start();new Thread(){@Overridepublic void run() {for (int i = 0; i < 100; i++) {if(i % 2 != 0)System.out.println(Thread.currentThread().getName() + ":" + i);}}}.start();}}
方式二：实现Runnable接口
步骤
- 创建一个实现了 Runnable 接口的类
- 实现类去实现 Runnable 中的抽象方法：run()
- 创建实现类的对象
- 将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
通过Thread类的对象调用start() ```java // 1.创建一个实现了Runnable接口的类 class MThread implements Runnable {
// 2.实现类去实现Runnable中的抽象方法：run() @Override public void run() {
for (int i = 0; i < 100; i++) {if(i % 2 == 0){System.out.println(Thread.currentThread().getName() + ":" + i);}}
} }
public class RunnableTest { public static void main(String[] args) {
// 3.创建实现类的对象MThread mThread = new MThread();// 4.将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象Thread t1 = new Thread(mThread);t1.setName("线程1");// 5.通过Thread类的对象调用start():① 启动线程 ②调用当前线程的run()//-->调用了Runnable类型的target的run()t1.start();//再启动一个线程，遍历100以内的偶数Thread t2 = new Thread(mThread, "线程2");t2.start();}
}
例子：创建三个窗口卖票，总票数为100张.使用实现Runnable接口的方式<br />存在线程的安全问题，待解决```javaclass Window implements Runnable{private int ticket = 100;@Overridepublic void run() {while(true){if(ticket > 0){System.out.println(Thread.currentThread().getName()+ ":卖票，票号为：" + ticket--);}elsebreak;}}}public class WindowTest1 {public static void main(String[] args) {Window w = new Window();Thread t1 = new Thread(w, "窗口1");Thread t2 = new Thread(w, "窗口2");Thread t3 = new Thread(w, "窗口3");t1.start();t2.start();t3.start();}}
比较创建线程的两种方式
开发中：优先选择：实现Runnable接口的方式
- 原因：
- 实现的方式没有类的单继承性的局限性
- 实现的方式更适合来处理多个线程有共享数据的情况
- 联系：public class Thread implements Runnable
- 相同点
- 两种方式都需要重写run()，将线程要执行的逻辑声明在run()中
- 要启动线程都要调用Thread类的start()方法
Thread类的方法
构造器
**Thread()****Thread(String threadname)**创建线程并指定线程实例名**Thread(Runnable target)**指定创建线程的目标对象，它实现了Runnable接口中的run方法**Thread(Runnable target, String name)**
方法
**void start()**启动当前线程；调用当前线程的run()**void run()**通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中**boolean isAlive()**判断当前线程是否存活**String getName()**获取当前线程的名字**void setName(String name)**设置当前线程的名字**static Thread currentThread()**静态方法，返回执行当前代码的线程**static void yield()**
- 释放当前cpu的执行权直接进入就绪状态，把执行机会让给优先级相同或更高的线程
- 若队列中没有同优先级的线程，忽略此方法
**void join()**
- 在线程a中调用线程b.join();此时线程a就进入阻塞状态，直到线程b完全执行完以后，线程a才结束阻塞
- b.join();就是b在插队，低优先级的线程也可以获得执行
**static void sleep(long millis) throw InterruptedException**
- 让正在运行的线程进入阻塞状态，直到休眠时间满了，进入就绪状态，使其他线程有机会被执行，时间到后重排队，会抛出InterruptedException异常
suspend() resume() stop() destory()已过时
线程优先级
Java线程的调度策略 同优先级线程组成先进先出队列（先到先服务），使用时间片策略 对高优先级，使用优先调度的抢占式策略
就绪状态的线程会进入“就绪队列”等待JVM来挑选，线程的优先级用数字表示
范围从1到10，一个线程的缺省优先级是5**void setPriority()****int getPriority()**
| Thread.MIN_PRIORITY | 1 |
|---|---|
| Thread.NORM_PRIORITY | 5 |
| Thread.MAX_PRIORITY | 10 |
说明
- 线程创建时继承父线程的优先级
低优先级只是获得调度的概率低，并非一定是在高优先级线程之后才被调用 ```java class HelloThread extends Thread {
public HelloThread(String name) {
super(name);
}
@Override public void run() {
for (int i = 0; i < 100; i++) {if(i % 2 == 0){try {sleep(10);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName() + ":"+ Thread.currentThread().getPriority() + ":" + i);}
// if(i % 20 == 0){ // yield(); // }
}
} }
public class ThreadMethodTest { public static void main(String[] args) { HelloThread h1 = new HelloThread(“Thread：1”); // h1.setName(“线程一”);
//设置分线程的优先级h1.setPriority(Thread.MAX_PRIORITY);h1.start();//给主线程命名Thread.currentThread().setName("主线程");Thread.currentThread().setPriority(Thread.MIN_PRIORITY);for (int i = 0; i < 100; i++) {if(i % 2 == 0){System.out.println(Thread.currentThread().getName() + ":"+ Thread.currentThread().getPriority() + ":" + i);}// if(i == 20){// try {// h1.join();// } catch (InterruptedException e) {// e.printStackTrace();// }// }}System.out.println(h1.isAlive());}
}
---<a name="660ab43c8619b6bd2c420ca0d26b940b"></a>## JDK 5.0新增线程创建方式**如何理解实现Callable接口的方式创建多线程比实现Runnable接口创建多线程方式强大**- call()可以返回值的- call()可以抛出异常，被外面的操作捕获，获取异常的信息- Callable是支持泛型的- 需要借助FutureTask类，比如获取返回值结果**Future接口**<br />- 可以对具体Runnable、Callable任务的执行结果进行取消、查询是否完成、获取结果等。- FutrueTask是Futrue接口的唯一的实现类- FutureTask同时实现了Runnable, Future接口。它既可以作为Runnable被线程执行，又可以作为Future得到Callable的返回值<a name="c73d47a0e3fcd79385300094def00efb"></a>### 新增方式一：实现Callable接口**实现方法**1. 创建一个实现 **Callable **的实现类1. 实现call方法，将此线程需要执行的操作声明在call()中1. 创建Callable接口实现类的对象1. 将此Callable接口实现类的对象作为传递到**FutureTask**构造器中，创建FutureTask的对象1. 将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()1. 获取Callable中call方法的返回值```java// 1.创建一个实现Callable的实现类class NumThread implements Callable {// 2.实现call方法，将此线程需要执行的操作声明在call()中@Overridepublic Object call() throws Exception {int sum = 0;for (int i = 1; i <= 100; i++) {if(i % 2 == 0){System.out.println(i);sum += i;}}return sum;}}public class ThreadNew {public static void main(String[] args) {//3.创建Callable接口实现类的对象NumThread numThread = new NumThread();//4.将此Callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象FutureTask futureTask = new FutureTask(numThread);//5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()new Thread(futureTask).start();try {//6.获取Callable中call方法的返回值//get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值。Object sum = futureTask.get();System.out.println("总和为：" + sum);} catch (InterruptedException e) {e.printStackTrace();} catch (ExecutionException e) {e.printStackTrace();}}}
新增方式二：使用线程池
背景：经常创建和销毁、使用量特别大的资源，比如并发情况下的线程对性能影响很大
解决方案
提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中
可以避免频繁创建销毁、实现重复利用。类似生活中的公共交通工具
相关API
JDK 5.0起提供了线程池相关API： ExecutorService和Executors
- ExecutorService：真正的线程池接口。常见子类 ThreadPoolexecutor
**void execute(Runnable command)**执行任务/命令，没有返回值，一般用来执行Runnable**<T> Future<T> submit(Callable<T> task)**执行任务，有返回值，一般又来执行Callable**void shutdown()**关闭连接池
- Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池
**Executors.newCachedThreadPool()**创建一个可根据需要创建新线程的线程池**Executors.newFixedthreadPool(n)**创建一个可重用固定线程数的线程池**Executors.newSingleThreadEXecutor()**创建一个只有一个线程的线程池**Executors.newScheduledThreadPool**创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行
实现方法
- 提供指定线程数量的线程池
- 执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象
- 关闭连接池
```java
class NumberThread implements Runnable{
@Override
public void run() {
} }for(int i = 0;i <= 100;i++){if(i % 2 == 0){System.out.println(Thread.currentThread().getName() + ": " + i);}}
class NumberThread1 implements Runnable{ @Override public void run() { for(int i = 0;i <= 100;i++){ if(i % 2 != 0){ System.out.println(Thread.currentThread().getName() + “: “ + i); } } } }
public class ThreadPool { public static void main(String[] args) { // 1.提供指定线程数量的线程池 ExecutorService service = Executors.newFixedThreadPool(10); ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;
//设置线程池的属性
// System.out.println(service.getClass()); // service1.setCorePoolSize(15); // service1.setKeepAliveTime();
// 2.执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象service.execute(new NumberThread()); //适合适用于Runnableservice.execute(new NumberThread1()); //适合适用于Runnable
// service.submit(Callable callable); //适合使用于Callable
//3.关闭连接池service.shutdown();}
}
**应用线程池的好处**1. 提高响应速度（减少了创建新线程的时间）1. 提高资源重用率，降低资源消耗（重复利用线程池中线程，不需要每次都创建）1. 便于线程管理- `**corePoolSize**`核心池的大小线程池中会维护一个最小的线程数量，即使这些线程处理空闲状态，他们也不会被销毁，除非设置了`allowCoreThreadTimeOut`。这里的最小线程数量即是`corePoolSize`- `**maximumPoolSize**`最大线程数一个任务被提交到线程池以后，首先会找有没有空闲存活线程，如果有则直接将任务交给这个空闲线程来执行，如果没有则会缓存到工作队列（后面会介绍）中，如果工作队列满了，才会创建一个新线程，然后从工作队列的头部取出一个任务交由新线程来处理，而将刚提交的任务放入工作队列尾部。线程池不会无限制的去创建新线程，它会有一个最大线程数量的限制，这个数量即由`maximunPoolSize`指定- `**keepAliveTime**`线程没任务时最多保持多长时间后会终止一个线程如果处于空闲状态，并且当前的线程数量大于`corePoolSize`，那么在指定时间后，这个空闲线程会被销毁，这里的指定时间由`keepAliveTime`来设定- `**unit**`空闲线程存活时间单位- keepAliveTime的计量单位- `**workQueue**`工作队列 [**https://www.yuque.com/cessstudy/javase/katpp3#A1h1q**](https://www.yuque.com/cessstudy/javase/katpp3#A1h1q)- 新任务被提交后，会先进入到此工作队列中，任务调度时再从队列中取出任务- `**threadFactory**`线程工厂- 创建一个新线程时使用的工厂，可以用来设定线程名、是否为daemon线程等等- `**handler**`拒绝策略- 当工作队列中的任务已到达最大限制，并且线程池中的线程数量也达到最大限制，这时如果有新任务提交进来，该如何处理呢。这里的拒绝策略，就是解决这个问题的，jdk中提供了4中拒绝策略- `**CallerRunsPolicy**`- 该策略下，在调用者线程中直接执行被拒绝任务的run方法，即发起者执行run。除非线程池已经shutdown，则直接抛弃任务。- `**AbortPolicy**`- 该策略下，直接丢弃任务，并抛出RejectedExecutionException异常- `**DiscardPolicy**`- 该策略下，直接丢弃任务，什么都不做。- `**DiscardOldestPolicy**`- 该策略下，抛弃进入队列最早的那个任务，然后尝试把这次拒绝的任务放入队列**面试题：Java中多线程的创建有几种方式？四种**- JDK 5.0以前- 即继承Thread类重run方法- 实现Runnable接口实现run方法- JDK 5.0以后- 实现callable接口，实现call方法- 利用线程池线程池怎么设置线程数？- `CPU`密集型：`CPU`数+1- 如此设置是尽量防止`CPU`切换- `IO`密集型：`CPU`数*2，或者`CPU`数/(1-阻塞系数)，阻塞系数一般在0.8~0.9之间- `IO`操作会有大量的阻塞，要尽量让`CPU`在一个线程阻塞时执行其他线程---<a name="0a534fe2be8bd104c1c93c816191626a"></a>## 线程的分类Java中的线程分为两类- **用户线程**- **守护线程**- 它们在几乎每个方面都是相同的，唯一的区别是判断JVM何时离开。形象理解：兔死狗烹，鸟尽弓藏- 守护线程是为用户线程服务的- 虚拟机必须确保用户线程执行完毕，不用等待守护线程执行完毕- 如后台记录操作日志、监控内存使用 Java垃圾回收等注意：**守护线程不能持有任何需要关闭的资源**，例如打开文件等，因为虚拟机退出时，守护线程没有任何机会来关闭文件，这会导致数据丢失。```javaThread t = new God();t.setDaemon(true);//把一个用户线程变成一个守护线程t.start();
若有收获，就点个赞吧
0 人点赞
