1.基本概念：程序、进程、线程
1.1 程序(program)
概念：是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码。
1.2 进程(process)
概念：程序的一次执行过程，或是正在运行的一个程序。 说明：进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域。
1.3 线程(thread)
概念：进程可进一步细化为线程，是一个程序内部的一条执行路径。 说明：线程作为调度和执行的单位，每个线程拥独立的运行栈和程序计数器(pc)，线程切换的开销小。
2.并行与并发
2.1 单核CPU和多核CPU
单核CPU，其实是一种假的多线程，因为在一个时间单元内，也只能执行一个线程的任务。涉及到CPU处理线程的方式，CPU在单位时间（也就是说一个时间片内）内只能处理一个线程，于是就将其他的线程设置为阻塞状态，加入到阻塞队列中，等到处理完成当前线程后从就绪队列中取出新的线程进行处理，由于切换和处理时间很快用户感知不到，于是用户便认为CPU在同一时间内处理多个线程。
>多核CPU，才能更好的发挥多线程的效率。（现在的服务器都是多核的）
>一个Java应用程序java.exe，其实至少三个线程：main()主线程，gc()垃圾回收线程，异常处理线程。当然如果发生异常，会影响主线程。2.2并行与并发的理解
并行：多个CPU同时执行多个任务。比如：多个人同时做不同的事。
>并发：一个CPU(采用时间片)同时执行多个任务。比如：秒杀、多个人做同一件事为什么要使用多线程？
当我们在进行商品抢购的时候，在支付按钮上总是有个计时器在进行倒计时，但是我们此时仍然可以进行商品信息的查看，这个计时器和我们浏览商品信息的线程是同时进行的，这样也就实现了抢购场景，增加了用户的体验。
1.多线程的优点
- 提高应用程序的响应。对图形化界面更有意义，可增强用户体验。
- 提高计算机系统CPU的利用率。
改善程序结构。将既长又复杂的进程分为多个线程，独立运行，利于理解和修改。
2.应用场景
程序需要同时执行两个或多个任务。
- 程序需要实现一些需要等待的任务时，如用户输入、文件读写操作、网络操作、搜索等
- 需要一些后台运行的程序时
3.Thread类
Java语言的JVM允许程序运行多个线程，它通过 java. lang.Thread类来体现3.1线程的创建方式一：继承Thread类
```java package com.test.java;
/**
- 多线程的创建，方式一：继承于Thread类
- 1.创建一个继承于Thread类的子类
- 2.重写Thread类中的run()方法
- 3.创建子类对象
- 4.调用start()方法 *
- 例子：遍历100以内的所有偶数
*/
public class ThreadTest {
public static void main(String[] args) {
} }MyThread t = new MyThread();t.start();//1.启动当前线程 2.调用当前线程的run()方法for (int i = 0; i <= 100; i++) {if (i % 2 != 0) {System.out.println(i + "******主线程");}}
class MyThread extends Thread { @Override public void run() { for (int i = 0; i <= 100; i++) { if (i % 2 == 0) { System.out.println(i + “**线程”); } } } }
<a name="ZVZqn"></a>### 3.2方式一练习```javapackage com.test.exer;/*** 练习：创建两个分线程，其中一个线程遍历100以内的偶数，另一个线程遍历100以内的奇数*/public class ThreadDemo {public static void main(String[] args) {// MyThread1 t1 = new MyThread1();// MyThread2 t2 = new MyThread2();// t1.start();// t2.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();new Thread(){@Overridepublic void run() {for (int i = 0; i < 100; i++) {if (i % 2 != 0) {System.out.println(Thread.currentThread().getName() + i);}}}}.start();}}class MyThread1 extends Thread {@Overridepublic void run() {for (int i = 0; i < 100; i++) {if (i % 2 == 0) {System.out.println(Thread.currentThread().getName() + i);}}}}class MyThread2 extends Thread {@Overridepublic void run() {for (int i = 0; i < 100; i++) {if (i % 2 != 0) {System.out.println(Thread.currentThread().getName() + i);}}}}
3.3线程的常用方法
package com.test.java;/*** 测试Thread类的常用方法* 1.start()方法：启动当前线程；调用当前线程的run()方法* 2.run()方法：重写此方法，写创建该线程需要执行的操作* 3.CurrentThread()方法：静态方法，返回执行当前代码的线程* 4.getName()方法：获取当前线程的名字* 5.setName()方法：设置当前线程的名字* 6.yield()方法：释放当前CPU执行权* 7.join()方法：在线程a中调用线租b的join(),此时线程a就进入阻塞状态，直到线程b完全执行完以后，线程q才结束阳塞状杰* 8.stop()方法：强制结束此线程* 9.sleep()方法：阻塞此线程多少毫秒* 10.isAlive()方法：判断该线程是否存活*/public class ThreadMethodTest {public static void main(String[] args) {HelloThread h = new HelloThread("线程一");//h.setName("线程一");setName()方法命名h.start();//给主线程命名Thread.currentThread().setName("主线程");for (int i = 0; i <= 100; i++) {if (i % 2 == 0) {System.out.println(i + "******" + Thread.currentThread().getName());}if (i == 20) {try {h.join();} catch (InterruptedException e) {e.printStackTrace();}}}System.out.println(h.isAlive());//false}}class HelloThread extends Thread {@Overridepublic void run() {for (int i = 0; i <= 100; i++) {if (i % 2 == 0) {System.out.println(i + "******" + Thread.currentThread().getName());}try {sleep(2000);} catch (InterruptedException e) {e.printStackTrace();}if (i % 20 == 0) {yield();}}}//构造器方式命名public HelloThread(String name){super(name);}}
3.4线程优先级的设置
package com.test.java;/*** 线程优先级* 1.MAX_PRIORITY 10* 2.MIN_PRIORITY 1* 3.NORM_PRIORITY 5* 4.getPriority():获取线程的优先级* 5.setPriority():设置线程的优先级* 注：并不是高优先级一定先执行，而是高概率执行*/public class ThreadTest {public static void main(String[] args) {MyThread t = new MyThread();t.setPriority(Thread.MAX_PRIORITY);t.start();for (int i = 0; i <= 100; i++) {if (i % 2 != 0) {System.out.println(i + "******主线程");}}}}class MyThread extends Thread {@Overridepublic void run() {for (int i = 0; i <= 100; i++) {if (i % 2 == 0) {System.out.println(i + "******线程");}}}}
3.5例题：方式一 继承Thread的多窗口卖票
package com.test.java;/*** 例：创建三个窗口卖票，总票数为100张* 存在线程的安全问题：待解决*/public class WindowTest {public static void main(String[] args) {Window w1 = new Window();Window w2 = new Window();Window w3 = new Window();w1.setName("窗口1");w2.setName("窗口2");w3.setName("窗口3");w1.start();w2.start();w3.start();}}class Window extends Thread{private static int ticket = 100;@Overridepublic void run() {while (true){if (ticket > 0){System.out.println(this.getName() + "卖票，票号为" + (101 - ticket));ticket--;}else {break;}}}}
3.6线程的创建方式二：实现Runnable接口
package com.test.java;/*** 创建多线程的方式二：实现Runnable接口* 1.创建一个实现了Runnable接口的类* 2.实现类去实现Runnable中的抽象方法:run()* 3.创建实现类的对象* 4.将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象* 5.通过Thread类的对象调用start()*/public class ThreadTest1 {public static void main(String[] args) {//3.创建实现类的对象MThread m = new MThread();//4.将对象传入Thread构造器中Thread t = new Thread(m);//5.通过Thread类的对象调用start()t.start();}}//1.创建一个实现Runnable接口的类class MThread implements Runnable{//2.重写run方法@Overridepublic void run() {for (int i = 0; i <= 100; i++) {if (i % 2 != 0) {System.out.println(i + "******线程");}}}}
3.7例题：方式二 实现Runnable接口的多窗口卖票
package com.test.java;/*** 例：创建三个窗口卖票，总票数为100张，使用Runnable接口方式* 存在线程的安全问题：待解决*/public class WindowTest1 {public static void main(String[] args) {MyThread1 m = new MyThread1();Thread t1 = new Thread(m);Thread t2 = new Thread(m);Thread t3 = new Thread(m);t1.setName("窗口1");t2.setName("窗口2");t3.setName("窗口3");t1.start();t2.start();t3.start();}}class MyThread1 implements Runnable{//此处没有static因为上面传入Thread类的是一个对象不是多个private int ticket = 100;@Overridepublic void run() {while (true){if (ticket > 0){System.out.println(Thread.currentThread().getName()+"卖票成功,票号:"+ ticket);ticket--;}else {break;}}}}
3.8继承方式和实现方式的联系与区别
/*** 继承方式和实现方式的联系与区别* 比较创建线程的两种方式。* 开发中：优先选择：实现Runnable接口的方式* 原因：1. 实现的方式没有类的单继承性的局限性* 2. 实现的方式更适合来处理多个线程有共享数据的情况。** 联系：public class Thread implements Runnable* 相同点：两种方式都需要重写run(),将线程要执行的逻辑声明在run()中。*/
4.线程的生命周期
新建：当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态
就绪：处于新建状态的线程被start()后，将进入线程队列等待CPU时间片，此时它已具备了运行的条件，只是没分配到CPU资源
运行：当就绪的线程被调度并获得CPU资源时,便进入运行状态，run()方法定义了线程的操作和功能
阻塞：在某种特殊情况下，被人为挂起或执行输入输出操作时，让出CPU并临时中止自己的执行，进入阻塞状态
死亡：线程完成了它的全部工作或线程被提前强制性地中止或出现异常导致结束
5.线程的同步
5.1理解线程的安全问题
*问题的提出:
>多个线程执行的不确定性引起执行结果的不稳定
>多个线程对账本的共享，会造成操作的不完整性，会破坏数据。
下面两个线程如果if同时判断的话，就会欠债了！（不允许这种情况发生）
5.2线程安全问题的举例
package com.test.java;/*** 存在线程的安全问题：有重票，错票*/public class WindowTest1 {public static void main(String[] args) {MyThread1 m = new MyThread1();Thread t1 = new Thread(m);Thread t2 = new Thread(m);Thread t3 = new Thread(m);t1.setName("窗口1");t2.setName("窗口2");t3.setName("窗口3");t1.start();t2.start();t3.start();}}class MyThread1 implements Runnable{//此处没有static因为上面传入Thread类的是一个对象不是多个private int ticket = 100;@Overridepublic void run() {while (true){if (ticket > 0){//多加一个sleep()就是让线程通过判断条件后在卖票，这样ticket--执行就是或许同步执行的了，重票概率大大增加try {Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName()+"卖票成功,票号:"+ ticket);ticket--;}else {break;}}}}
5.3同步代码块处理实现Runnable的线程安全问题
package com.test.java;/*** 1.问题：卖票过程中出现了重票错票-->线程的安全问题* 2.原因：当某个线程操作ticket的过程中尚未完成时，其他线程就加入进来操作ticket* 3.解决：当一个线程在操作共享数据(ticket)的时候，其他线程不能参与进来。直到该线程操作完共享数据(ticket)后，其他线程才能操作。* 4.在Java中我们通过同步机制来解决这个问题。* 方式一：同步代码块* synchronized(同步监视器){* 需要被同步的代码* }* 说明：1.操作共享下数据的代码即为需要同步的代码* 2.共享数据：多个线程共同操作的变量，此例为ticket* 3.同步监视器：俗称 锁 任何一个类的对象都可以充当锁* 要求：多个线程必须要用同一把锁** 方式二：同步方法** 5.同步的方式，解决了线程的安全问题。---好处* 操作同步代码时，只能有一个线程参与，其他线程等待。相当于是一个单线程的过程，效率低。---局限性*/public class WindowTest1 {public static void main(String[] args) {MyThread1 m = new MyThread1();Thread t1 = new Thread(m);Thread t2 = new Thread(m);Thread t3 = new Thread(m);t1.setName("窗口1");t2.setName("窗口2");t3.setName("窗口3");t1.start();t2.start();t3.start();}}class MyThread1 implements Runnable{//此处没有static因为上面传入Thread类的是一个对象不是多个private int ticket = 100;final Object obj = new Object();@Overridepublic void run() {while (true){//用了同步锁之后就是舒服捏//synchronized(obj){//this也行synchronized (this){if (ticket > 0){//多加一个sleep()就是让线程通过判断条件后在卖票，这样ticket--执行就是或许同步执行的了，重票概率大大增加try {Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName()+"卖票成功,票号:"+ ticket);ticket--;}else {break;}}}}}
5.4同步代码块处理继承Thread类的线程安全问题
package com.test.java;/*** 使用同步代码块解决继承Thread类的方式的线程安全问题** 例子：创建三个窗口卖票，总票数为100张*/class Windows extends Thread{private static int ticket = 100;//共用同一把锁,obj要加staticprivate static final Object obj = new Object();@Overridepublic void run() {while(true){//正确的// synchronized (obj) {synchronized (Windows.class){ //Class clazz = Windows.class//错误的，因为此时this表示的是t1,t2,t3三个对象// synchronized (this) {if (ticket > 0) {try {Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(getName() + ":卖票，票号为: " + ticket);ticket--;} else {break;}}}}}public class WindowsTest2 {public static void main(String[] args) {Windows t1 = new Windows();Windows t2 = new Windows();Windows t3 = new Windows();t1.setName("窗口1");t2.setName("窗口2");t3.setName("窗口3");t1.start();t2.start();t3.start();}}
5.5同步方法处理实现Runnable的线程安全问题
package com.test.java;/*** 使用同步方法解决实现Runnable接口的线程安全问题** 关于同步方法的总结:* 1. 同步方法仍然涉及到同步监视器，只是不需要我们显式的声明。* 2. 非静态的同步方法，同步监视器是：this* 静态的同步方法，同步监视器是：当前类本身*/class Windows3 implements Runnable {private int ticket = 100;@Overridepublic void run() {while (true) {show();}}private synchronized void show() { //同步监视器:this// synchronized (this){if (ticket > 0) {try {Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName() + ":卖票，票号为: " + ticket);ticket--;}// }}}public class WindowsTest3 {public static void main(String[] args) {Windows3 w3 = new Windows3();Thread t1 = new Thread(w3);Thread t2 = new Thread(w3);Thread t3 = new Thread(w3);t1.setName("窗口1");t2.setName("窗口2");t3.setName("窗口3");t1.start();t2.start();t3.start();}}
5.6同步方法处理继承Thread类的线程安全问题
package com.test.java;/*** 使用同步方法处理继承Thread类的方式中的线程安全问题*/class Windows4 extends Thread {private static int ticket = 100;@Overridepublic void run() {while (true) {show();}}private static synchronized void show(){//同步监视器：Window4.class//private synchronized void show(){ //同步监视器：t1,t2,t3。此种解决方式是错误的if (ticket > 0) {try {Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName() + "：卖票，票号为：" + ticket);ticket--;}}}public class WindowsTest4 {public static void main(String[] args) {Windows4 t1 = new Windows4();Windows4 t2 = new Windows4();Windows4 t3 = new Windows4();t1.setName("窗口1");t2.setName("窗口2");t3.setName("窗口3");t1.start();t2.start();t3.start();}}
5.7线程安全的单例模式之懒汉式
package com.test.java;/*** 使用同步机制将单例模式中的懒汉式改写为线程安全的*/public class BankTest {}class Bank{//构造器private Bank(){}private static Bank instance = null;public static Bank getInstance() {//方式一：效率稍差// synchronized (Bank.class) {// if(instance == null){// instance = new Bank();// }// return instance;// }//方式二：效率较高if (instance == null) {synchronized (Bank.class) {if (instance == null) {instance = new Bank();}}}return instance;}}
5.8线程的死锁问题
形象理解：打架都让对方放手，都不放手
package com.test.java;/*** 演示线程的死锁问题：* 1.死锁的理解：不同的线程分别占用对方需要的同步资源不放弃，* 都在等待对方放弃自己需要的同步资源，就形成了线程的死锁* 2.说明:* >出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续* >我们使用同步时，要避免出现死锁。*/public class DeadLock {public static void main(String[] args) {StringBuffer str1 = new StringBuffer();StringBuffer str2 = new StringBuffer();new Thread(){@Overridepublic void run() {synchronized (str1){str1.append("a");str2.append("1");//这个线程等着拿str2这个锁try {Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}synchronized (str2){str1.append("b");str2.append("2");System.out.println(str1);System.out.println(str2);}}}}.start();new Thread(new Runnable() {@Overridepublic void run() {synchronized (str2){str1.append("c");str2.append("3");//这个线程等着拿str1这个锁try {Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}synchronized (str1){str1.append("d");str2.append("4");System.out.println(str1);System.out.println(str2);}}}}).start();}}
5.9Lock锁方式解决线程安全问题
java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象。
>ReentrantLock类实现了Lock ，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁。
>从JDK 5.0开始，Java提供了更强大的线程同步机制——通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当。 ```java package com.test.java;
import java.util.concurrent.locks.ReentrantLock;
/**
- 解决线程安全问题三—>Lock锁 —-JDK5.0新增
- 面试题：synchronized 与 Lock的异同？
- 相同：二者都可以解决线程安全问题
- 不同：synchronized机制在执行完相应的同步代码以后，自动的释放同步监视器
- Lock需要手动的启动同步（lock()），同时结束同步也需要手动的实现（unlock()）
*/
public class LockTest {
public static void main(String[] args) {
MyThread m = new MyThread();
Thread t1 = new Thread(m);
Thread t2 = new Thread(m);
Thread t3 = new Thread(m);
t1.setName(“窗口1”);
t2.setName(“窗口2”);
t3.setName(“窗口3”);
t1.start();
t2.start();
t3.start();
}
}
class MyThread implements Runnable{
private int ticket = 100;
//1.实例化ReentranLock
private ReentrantLock lock = new ReentrantLock();
@Override
public void run() {
while (true) {
try {
} finally {//2.调用lock()lock.lock();if (ticket > 0) {System.out.println(Thread.currentThread().getName() + "卖票成功,票号:" + ticket);ticket--;} else {break;}
} } } } ```//解锁方法unlock()lock.unlock();
5.10线程练习
```java package com.test.java;
public class AccountTest { public static void main(String[] args) { Account acct = new Account(0); Customer c1 = new Customer(acct); Customer c2 = new Customer(acct); c1.setName(“甲”); c2.setName(“乙”); c1.start(); c2.start(); } } class Customer extends Thread{ private Account acct; public Customer(Account acct) { this.acct = acct; }
@Overridepublic void run() {for (int i = 0;i < 3;i++){try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}acct.deposit(1000);}}
} class Account{ private double balance; public Account(double balance) { this.balance = balance; } public synchronized void deposit(double amt){ balance+=amt; System.out.println(Thread.currentThread().getName() + “存钱成功，余额为：” + balance); } }
<a name="n3LZL"></a>## 6.线程的通信<a name="GyX01"></a>### 6.1举例和使用```javapackage com.test.java2;/*** 线程通信的例子：使用两个线程打印1-100。线程1, 线程2 交替打印** 涉及到的三个方法：* wait():一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器。* notify():一旦执行此方法，就会唤醒被wait的一个线程。如果有多个线程被wait，就唤醒优先级高的那个。* notifyAll():一旦执行此方法，就会唤醒所有被wait的线程。** 说明：* 1.wait()，notify()，notifyAll()三个方法必须使用在同步代码块或同步方法中。* 2.wait()，notify()，notifyAll()三个方法的调用者必须是同步代码块或同步方法中的同步监视器。* 否则，会出现IllegalMonitorStateException异常* 3.wait()，notify()，notifyAll()三个方法是定义在java.lang.Object类中。*/public class CommunicationTest {public static void main(String[] args) {Num n = new Num();Thread t1 = new Thread(n);Thread t2 = new Thread(n);t1.setName("线程1");t2.setName("线程2");t1.start();t2.start();}}class Num implements Runnable{private int num = 1;@Overridepublic void run() {while (true){synchronized (this){notify();if (num < 100){System.out.println(Thread.currentThread().getName() + "：" + num);num++;try {//使线程进入阻塞状态wait();} catch (InterruptedException e) {e.printStackTrace();}}else {break;}}}}}
6.2sleep()和wait()的异同
/*** 面试题：sleep() 和 wait()的异同？* 1.相同点：一旦执行方法，都可以使得当前的线程进入阻塞状态。* 2.不同点：1）两个方法声明的位置不同：Thread类中声明sleep() , Object类中声明wait()* 2）调用的要求不同：sleep()可以在任何需要的场景下调用。 wait()必须使用在同步代码块或同步方法中* 3）关于是否释放同步监视器：如果两个方法都使用在同步代码块或同步方法中，sleep()不会释放锁，wait()会释放锁。*/
6.3生产者/消费者问题
/*** 线程通信的应用：经典例题：生产者/消费者问题** 生产者(Productor)将产品交给店员(Clerk)，而消费者(Customer)从店员处取走产品，* 店员一次只能持有固定数量的产品(比如:20），如果生产者试图生产更多的产品，* 店员会叫生产者停一下，如果店中有空位放产品了再通知生产者继续生产；* 如果店中没有产品了，店员会告诉消费者等一下，* 如果店中有产品了再通知消费者来取走产品。** 分析：* 1.是否是多线程的问题？是，生产者的线程，消费者的线程* 2.是否有共享数据的问题？是，店员、产品、产品数* 3.如何解决线程的安全问题？同步机制，有三种方法* 4.是否涉及线程的通信？是*/class Clerk{private int productCount = 0;//生产产品public synchronized void produceProduct() {if(productCount < 20){productCount++;System.out.println(Thread.currentThread().getName() + ": 开始生产第" + productCount + "个产品");notify();}else{//等待try {wait();} catch (InterruptedException e) {e.printStackTrace();}}}//消费产品public synchronized void consumeProduct() {if(productCount > 0){System.out.println(Thread.currentThread().getName() + ":开始消费第" + productCount + "个产品");productCount--;notify();}else{//等待try {wait();} catch (InterruptedException e) {e.printStackTrace();}}}}class Producer extends Thread{//生产者private Clerk clerk;public Producer(Clerk clerk){this.clerk = clerk;}@Overridepublic void run() {System.out.println(getName() + ": 开始生产产品......");while(true){try {Thread.sleep(10);} catch (InterruptedException e) {e.printStackTrace();}clerk.produceProduct();}}}class Consumer extends Thread{ //消费者private Clerk clerk;public Consumer(Clerk clerk){this.clerk = clerk;}@Overridepublic void run() {System.out.println(getName() + ": 开始消费产品......");while(true){try {Thread.sleep(20);} catch (InterruptedException e) {e.printStackTrace();}clerk.consumeProduct();}}}public class ProductTest {public static void main(String[] args) {Clerk clerk = new Clerk();Producer p1 = new Producer(clerk);p1.setName("生产者1");Consumer c1 = new Consumer(clerk);c1.setName("消费者1");Consumer c2 = new Consumer(clerk);c2.setName("消费者2");p1.start();c1.start();c2.start();}}
7.JDK5.0新增创建线程的方式
7.1线程的创建方式三：实现Callable接口
package com.test.java2;import java.util.concurrent.Callable;import java.util.concurrent.ExecutionException;import java.util.concurrent.FutureTask;/*** 创建线程的方式三：实现Callable接口 ---JDK5.0新增* 如何理解实现Callable接口的方式创建多线程比实现Runnable接口创建多线程方式强大？* 1.call()可以有返回值的。* 2.call()可以抛出异常，被外面的操作捕获，获取异常的信息* 3.Callable是支持泛型的* 4.需要借助FutureTask类，比如获取返回结果*///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.将实例放入FutureTask的构造器中FutureTask<Integer> f = new FutureTask<Integer>(numthread);//5.将FutureTask类的对象放入Thread中Thread t = new Thread(f);t.start();try {Integer i = f.get();System.out.println("总和为" + i);} catch (InterruptedException | ExecutionException e) {e.printStackTrace();}}}
7.2使用线程池的好处
背景：经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大。
>思路：提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用。类似生活中的公共交通工具。
>好处：
- 提高响应速度（减少了创建新线程的时间）
- 降低资源消耗（重复利用线程池中线程，不需要每次都创建）
- 便于线程管理
/**
- 创建多线程的方式四：使用线程池 *
- 好处：
- 1.提高响应速度（减少了创建新线程的时间）
- 2.降低资源消耗（重复利用线程池中线程，不需要每次都创建）
- 3.便于线程管理
- corePoolSize：核心池的大小
- maximumPoolSize：最大线程数
- keepAliveTime：线程没有任务时最多保持多长时间后会终止 *
- 面试题：创建多线程有几种方式？四种！ */
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()); //适合适用于Runableservice.execute(new NumberThread1()); //适合适用于Runable
// service.submit(Callable callable); //适合适用于Callable
//3.关闭连接池service.shutdown();}
} ```
若有收获，就点个赞吧
0 人点赞
