多线程JavaSE
一、基本概念：程序、进程、线程
程序：为完成特定任务，用某一种语言编写地一组指令的集合。即指一段静态的代码，静态对象。
进程：是程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程：它有自身的产生、存在、消亡的过程。----声明周期。
例如：QQ的运行、IDEA的运行、360的运行
程序是静态的，进程是动态的。
线程：进程可以进一步细化为线程，是一个程序内部的一条执行路径。
一个进程中的多个线程共享相同的内存单元和内存地址空间，它们从同一堆中分配对象，可以访问相同的变量和对象。这就使得线程间通信更简便、高效。但多个线程操作共享的系统资源可能就会带来安全的隐患。
单核CPU与多核CPU的理解：
一个java.exe应用程序至少有三个线程：main()主线程序，gc垃圾回收线程，异常处理线程。
并行与并发：
并行：多个CPU同时执行多个任务。比如：多个人同时做不同的事。
并发：一个CPU(采用时间片)同时执行多个任务。比如：秒杀、多个人做同一个事。
使用多线程的优点：
1.提高应用程序的响应。对图形化界面更有意义，可增强用户体验。
2.提高计算机系统 CPU 的利用率
3.改善程序结构。将既长又复杂的进程分为多个线程，独立运行，利于理解和修改
何时需要多线程：
1.程序 需要同时执行两个或多个任务。
2.程序 需要实现一些需要等待的任务时，如用户输入、文件读写操作、网络操作、搜索等。
3.需要 一些后台运行的程序时。
二、线程的创建和使用（重点）（2种）
多线程的创建方式一：继承Thread类
1、创建一个继承与Thread类的子类
2、重写Thread类的run方法 ----->将此线程执行的操作声明在run()方法中
3、创建Thread类的子类对象
4、通过此对象调用start()
class MyThread extends Thread{
//2.重写run @Override public void run() { for (int i = 0; i < 100; i++){ if (i %2 == 0){ System.out.println(i); } } } } public class ThreadTest { public static void main(String[] args) { //3.创建Thread类子类的对象 MyThread t1 = new MyThread(); //4.调用start：①启动当前线程 ②调用当前线程的run()
t1.start();
//问题一：不能通过直接调用run()方法的方式启动线程。
//t1.run();
//问题二：再启动一个线程，遍历100以内的偶数。不可以让已经start()的线程取执行。会报异常。应该新建一个子类对象
t1.start(); //会抛异常 IllegalThreadStateException非法的线程状态
//需要重新创建一个线程的对象
MyThread t2 = new MyThread();
t2.start();
//如下操作仍然是在main线程中执行
for(int i = 0; i < 100; i++){
if(i%2 == 0){
System.out.println("-----------main()---------");
}
}
}
}
练习：创建两个分 线程 ，让其中一个线程输出100 之间的偶数，另一个线程输出100 之间的奇数。
class MyThread extends Thread{ @Override public void run() { for (int i = 0; i < 100; i++){ if (i%2 == 0){ System.out.println(Thread.currentThread().getName() + ":" +i); } } } } class MyThread2 extends Thread{ @Override public void run() { for (int i = 0; i < 100; i++){ if (i%2 != 0){ System.out.println(Thread.currentThread().getName() + ":" +i); } } } } public class ThreadDemo { public static void main(String[] args) { // MyThread m1 = new MyThread(); // MyThread2 m2 = new MyThread2(); // // m1.start(); // m2.start(); //创建Thread类的匿名子类的方式 new Thread(){ @Override public void run() { for (int i = 0; i < 100; i++){ if (i%2 == 0){ System.out.println(Thread.currentThread().getName() + ":" +i); } } } }.start(); new Thread(){ @Override public void run() { for (int i = 0; i < 100; i++){ if (i%2 != 0){ System.out.println(Thread.currentThread().getName() + ":" +i); } } } }.start(); } }
测试Thread类中的常用方法
/** * 测试Thread类中的常用方法 * 1.start()：启动当前线程；调用当前线程的run方法 * 2.run():通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中 * 3.currentThread()：静态方法，返回执行当前代码的线程 * 4.getName():获取当前线程的名字 * 5.setName()：设置 * 6.yield()：释放当前CPU的执行权 * 7.join():在线程A中调用线程B的jion方法，此时线程A就进入阻塞状态，直到线程B完全执行完以后，线程A才可以获取执行权 * 8.stop():已过时。当执行此方法时，强制结束当前线程。 * 9.sleep(long millitime)：让当前线程“睡眠”指定的毫秒数，在指定的毫秒时间内，当前线程是阻塞状态。 * 10.isAlive():判断当前线程是否存活。 * @author ldbstart * @create 2021-03-05 14:30 */ class HelloThread extends Thread{ @Override public void run() { for (int i = 0; i < 100; i++){ if (i%2 == 0){ System.out.println(Thread.currentThread().getName() + ":" +i); } // if (i % 20 == 0){ // this.yield(); //释放执行权 // } try { sleep(10); //阻塞一秒 } catch (InterruptedException e) { e.printStackTrace(); } } } public HelloThread(String name){ super(name); } } public class TreadMethodTest { public static void main(String[] args) { HelloThread h1 = new HelloThread("Thread:1"); //h1.setName("线程一"); h1.start(); Thread.currentThread().setName("主线程一："); for (int i = 0; i < 100; i++){ if (i%2 != 0){ System.out.println(Thread.currentThread().getName() + ":" +i); } if (i == 20){ try { h1.join(); //另外一个线程的join方法 } catch (InterruptedException e) { e.printStackTrace(); } } System.out.println(h1.isAlive()); } } }
线程的调度：
线程的优先级：
线程的优先级：
1.
MAX_PRIORITY 10
MIN PRIORITY 1
NORM_PRIORITY 5
2.如何获取和设置当前线程的优先级：
getPriority():获取线程的优先级
setPriotity()：设置线程的优先级
说明：高优先级的线程要抢占低优先级线程cpu的执行权。但是只是从概率上讲，高优先级的线程高概率的情况下被执行。并不意味着只有当高优先级的线程执行完以后，低优先级的线程才执行。
练习：创建三个窗口买票，总票数为100张。
package com.atguigu.javasenior; /** * 创建三个窗口买票，总票数为100张。 * 存在线程安全问题，待解决 * @author ldbstart * @create 2021-03-05 15:59 */ class Window extends Thread{ private static int ticket = 100; @Override public void run() { while (true){ if (ticket > 0){ System.out.println(getName() + ":卖票，票号为" + ticket); ticket --; }else{ break; } } } } public class WindowsTest { public static void main(String[] args) { Window w1 = new Window(); Window w2 = new Window(); Window w3 = new Window(); w1.setName("窗口一"); w2.setName("窗口二"); w3.setName("窗口三"); w1.start(); w2.start(); w3.start(); } }
创建多线程的方式二：实现Runnable接口
* 1.创建一个实现了Runnable接口的抽象类
* 2.实现类去实现Runnable接口中的抽象方法：run()
* 3.创建实现类的对象
* 4.将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
* 5.通过Thread类的对象调用start()
class MThread implements Runnable{ //2.实现 @Override public void run() { for (int i = 0; i < 100; i++){ if (i % 2 == 0){ System.out.println(i); } } } } public class ThreadTest1 { public static void main(String[] args) { //3.创建实现类的对象 MThread mThread = new MThread(); //4.将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象 Thread t1 = new Thread(mThread); //5.通过Thread类的对象调用start()①启动线程②调用当前线程的run()---->调用了Runnable类型的target的run()，（打开Thread的源码看run()方法） t1.start(); } }
/** * 使用Runnable接口的方式，三个窗口买100张票 * 存在线程安全问题，待解决 * @author ldbstart * @create 2021-03-05 16:28 */ class Windows1 implements Runnable{ private int ticket = 100; @Override public void run() { while (true){ if (ticket > 0){ System.out.println(Thread.currentThread().getName() + ":卖票，票号为" + ticket); ticket--; }else{ break; } } } } public class WindowTest1 { public static void main(String[] args) { Windows1 w = new Windows1(); Thread t1 = new Thread(w); Thread t2 = new Thread(w); Thread t3 = new Thread(w); t1.setName("窗口一"); t2.setName("窗口二"); t3.setName("窗口三"); t1.start(); t2.start(); t3.start(); } }
比较创建线程的两种方式：
开发中：优先选择实现Runnable接口的方式
原因:1.实现的方式没有类的单继承性的局限性
2.实现的方式更适合处理多个线程有共享数据的情况。
两种方式的联系：public class Thread implements Runnable
相同点：两种方式都需要重写run()方法，将线程要执行的逻辑声明在run()中。
三、线程的生命周期
新建：NEW
就绪：
运行：
阻塞：
死亡：TERMINATED
插个眼
四、线程的同步（重难点）（解决线程安全问题2+1种方法）
1.例如重票、错票问题，账户里3000块钱，你和你媳妇同时取2000，可能会出问题
2.问题描述：当某个线程操作车票的过程中，尚未完成时，其他线程参与进来，操作车票。
3.如何解决：当一个线程在操作ticket的时候，其他线程不能参与进来，直到线程a出现阻塞其他线程也不能参与进来。
4.在Java中，我们通过同步机制，来解决线程安全的问题。
5.同步的方式及，解决了线程的安全问题。----好处
操作同步代码块时，只能有一个线程参与，其他线程等待。相当于是一个单线程的过程，效率低。-----局限性
方式一：同步代码块
synchronized(同步监视器){
//需要被同步的代码
}
说明：
(1).操作共享数据的代码，即为需要被同步的代码。
(2).共享数据：多个线程共同操作的变量。--->不能包含多了，也不能包含少了
(3).同步监视器，俗称：锁。任何一个类的对象都可以充当锁。 ---->保证唯一性
锁的要求：多个线程必须同用一把锁！
补充(保证唯一性)：在实现Runnable接口创建多线程的方式中，我们可以考虑使用this充当同步监视器。
在继承Thread类创建多线程的方式中，要慎用this充当同步监视器，可以用当前类的class
class Windows1 implements Runnable{ private int ticket = 100; Object obj = new Object(); @Override public void run() { while (true){ synchronized (this) { //此时的this：唯一的Windows1的对象 ，注意区分继承Thread类的子类实现多线程功能时锁不能使用this if (ticket > 0) { System.out.println(Thread.currentThread().getName() + ":卖票，票号为" + ticket); ticket--; } else { break; } } } } } public class WindowTest1 { public static void main(String[] args) { Windows1 w = new Windows1(); Thread t1 = new Thread(w); Thread t2 = new Thread(w); Thread t3 = new Thread(w); t1.setName("窗口一"); t2.setName("窗口二"); t3.setName("窗口三"); t1.start(); t2.start(); t3.start(); } }
class Windows2 extends Thread{
private int ticket = 100;
@Override
public void run() {
while (true){
synchronized (Windows2.class) { //注意此时的同步监视器为:当前类本身
if (ticket > 0) {
System.out.println(Thread.currentThread().getName() + ":卖票，票号为" + ticket);
ticket--;
} else {
break;
}
}
}
}
}
=========================分隔线===========================
方式二：同步方法
如果操作共享数据的代码完整的生命在一个方法中，我们不妨将此方法生命为同步的。
package com.atguigu.java; /** * @author ldbstart * @create 2021-03-05 22:43 */ class Windows3 implements Runnable{ private int ticket = 100; Object obj = new Object(); @Override public void run() { while (true){ show(); } } //把操作共享数据的方法抽出来 public synchronized void show(){ //同步监视器是this if (ticket > 0) { try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + ":卖票，票号为" + ticket); ticket--; } } } public class WindowTest3 { public static void main(String[] args) { Windows1 w = new Windows1(); Thread t1 = new Thread(w); Thread t2 = new Thread(w); Thread t3 = new Thread(w); t1.setName("窗口一"); t2.setName("窗口二"); t3.setName("窗口三"); t1.start(); t2.start(); t3.start(); } }
/** * 同步方法解决继承Thread类创建多线程线程安全问题。 * * @author ldbstart * @create 2021-03-05 22:48 */ class Window4 extends Thread{ private static int ticket = 100; @Override public void run() { while (true){ show(); } } public static synchronized void show(){ //同步监视器为Window4.class 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) { Window4 w1 = new Window4(); Window4 w2 = new Window4(); Window4 w3 = new Window4(); w1.setName("窗口一"); w2.setName("窗口二"); w3.setName("窗口三"); w1.start(); w2.start(); w3.start(); } }
关于同步方法的总结：
1.同步方法仍然涉及到同步监视器，只是不需要我们显式的声明。
2.非静态的同步方法，同步监视器是this
静态的同步方法，同步监视器是：当前类本身
========================分隔线==========================
使用同步的方式将单例模式的懒汉式改为线程安全的。
注意面试中如果让写单例模式，要么写一个饿汉式，要么写一个线程安全的懒汉式。
//同步方法
public class BankTest { } class Bank{ private Bank(){ } private static Bank instance = null; public static synchronized Bank getInstance(){ if (instance == null){ instance = new Bank(); } return instance; } }
//同步代码块
public class BankTest2 { } class Bank2{ public Bank2(){ } private static Bank2 instance = null; public static Bank2 getInstance(){ //方式一：效率稍差 // synchronized (Bank.class) { // if (instance == null){ // instance = new Bank2(); // } // return instance; // } //方式二：效率更高 if (instance == null){ synchronized (Bank.class){ if (instance == null){ instance = new Bank2(); } } } return instance; } }
线程死锁问题
1.死锁的理解：不同的线程分别占用对放需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁。
2.说明：
(1).出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续
(2).我们使用同步时，尽量避免出现死锁。
解决线程安全问题的方式三：Lock锁 ---->JDK5.0新增
jdk5.0新特性，通过显式顶一个同步锁对象来实现同步。同步锁使用Lock对象充当
package com.atguigu.java1; import java.util.concurrent.locks.ReentrantLock; /** * 解决线程安全问题的方式三：Lock锁 ------JDK5.0新增 * * 1.面试题：synchronized和Lock锁的异同？ * 相同：都是可以解决线程安全问题 * 不同：synchronized机制在执行完响应的同步代码块以后，自动的释放同步监视器 * Lock需要手动的启动同步（lock()）,同时结束也需要手动的实现（unlock()） * * 2.优先使用顺序：Lock--->同步代码块(已经进入了方法体，分配了相应资源)--->同步方法(在方法体外) * * 面试题：如何解决线程安全问题？有几种方式 * 可以回答两种：同步代码块和同步方法算一种，Lock锁算一种 * 也可以回答三种：同步代码块、同步方法、Lock锁。 * @author ldbstart * @create 2021-03-06 15:22 */ class Window implements Runnable{ private int ticket = 100; //1.实例化ReentrantLock private ReentrantLock lock = new ReentrantLock(); //保证唯一的锁 @Override public void run() { while (true){ try { //2.调用lock锁定方法【类似于获取同步监视器】 lock.lock(); //注意此时是实现Runnable接口的方式，如果是继承Tread类的方式lock要加static修饰，保证锁的唯一性 if (ticket > 0){ try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + ":售票，票号为" + ticket); ticket--; }else{ break; } }finally { //3.调用解锁的方法 lock.unlock(); } } } } public class LockTest { public static void main(String[] args) { Window window = new Window(); Thread t1 = new Thread(window); Thread t2 = new Thread(window); Thread t3 = new Thread(window); t1.start(); t2.start(); t3.start(); } }
三种解决线程安全问题的方式小练习：
package com.atguigu.exer; /** *有两个储户 * 分别向同一个账户存 3000 元， 每次存 1000 存 3 次 。每次存完打印账户余额。 * 问题： * 该程序是否有安全问题，如果有，如何解决？ * 分析： * 1.是否是多线程问题？是 * 2.是否有共享数据？是，账户 * 3.是否有线程安全问题？是 * 4.如何解决线程安全问题？三种机制 * @author ldbstart * @create 2021-03-06 15:45 */ class Account{ private double balance; public Account(double balance) { this.balance = balance; } //存钱方法 public void deposit(double amt){ if (amt > 0){ balance += amt; try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + ":存钱成功，余额为：" + balance); } } } class Customer extends Thread{ private Account acct; public Customer(Account acct){ this.acct = acct; } @Override public void run() { for (int i = 0; i < 3; i++) { acct.deposit(1000); } } } 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(); } }
打印结果：
乙:存钱成功，余额为：2000.0
甲:存钱成功，余额为：2000.0
甲:存钱成功，余额为：4000.0
乙:存钱成功，余额为：4000.0
乙:存钱成功，余额为：6000.0
甲:存钱成功，余额为：6000.0
五、线程的通信（几个方法的使用，不难）
线程通信的例子：使用两个线程打印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中，方便任何一个对象都可以充当同步监视器
class Number implements Runnable{ private int number = 1; @Override public void run() { while (true){ synchronized (this) {//唯一的number对象 notify(); try { Thread.sleep(10); } catch (InterruptedException e) { e.printStackTrace(); } if (number < 100){ System.out.println(Thread.currentThread().getName() + ":" + number); number++; try { //使得调用如下wait()方法的线程进入阻塞状态 wait(); } catch (InterruptedException e) { e.printStackTrace(); } }else{ break; } } } } } public class CommunicationTest { public static void main(String[] args) { Number number = new Number(); Thread t1 = new Thread(number); Thread t2 = new Thread(number); t1.setName("线程1"); t2.setName("线程2"); t1.start(); t2.start(); } }
面试题
sleep()和wait()的异同？
1.相同点：一旦执行方法，都可以使当前的线程进入阻塞状态。
2.不同点：
（1）两个方法声明的位置不同：Thread类中声明sleep()，Object类中声明wait()
（2）调用的范围或者要求是不一样的。sleep( )可以在任何需要的场景下调用，wait( )必须使用在同步代码块或者同步方法中
（3）关于是否释放同步监视器：假设他们两个都使用在同步代码块或同步方法中，sleep( )不会释放同步监视器（锁），wait( )会释放锁。
线程通信的应用经典例题：生产者/消费者问题
package com.atguigu.java2; /** * 生产者 Productor 将产品交给店员 ( Clerk)，而消费者 ( 从店员处 * 取走产品，店员一次只能持有固定数量的产品 比如 :20 ），如果生产者试图 * 生产更多的产品，店员会叫生产者停一下，如果店中有空位放产品了再通 * 知生产者继续生产；如果店中没有产品了，店员会告诉消费者等一下，如 * 果店中有产品了再通知消费者来取走产品。 * * 分析： * 1.是否是多线程？是 * 2.是否有共享数据？是，店员（或产品） * 3.是否存在线程安全问题？是 * 3.如何解决线程的安全问题？同步机制，有三种方法 * 4.是否涉及线程通信？是，wait、notify * @author ldbstart * @create 2021-03-06 17:29 */ class Clerk{ private int productCount = 0; //体现在数量上是安全，此处不创建具体产品 //生产产品 public synchronized void produceProduct() { //此时的同步监视器是this if(productCount < 20){ productCount++; System.out.println(Thread.currentThread().getName() + ":开始生产第：" + productCount + "个产品"); notify(); //唤醒消费者来消费 }else{ try { wait(); } catch (InterruptedException e) { e.printStackTrace(); } } } //消费产品 public synchronized void consumerProduct() { //生产执行完，才可以执行消费 if (productCount > 0){ System.out.println(Thread.currentThread().getName() + ":开始消费第：" + productCount +"个产品"); productCount--; notify(); //唤醒生产者生产 }else { //产品小于或等于0 try { wait(); } catch (InterruptedException e) { e.printStackTrace(); } } } } class Producer extends Thread{ //生产者 private Clerk clerk; public Producer(Clerk clerk){ this.clerk = clerk; } @Override public void run() { System.out.println("生产者"+ Thread.currentThread().getName() + ":开始生产产品....."); //一顿生产猛如虎 while (true){ try { Thread.sleep(200); } catch (InterruptedException e) { e.printStackTrace(); } clerk.produceProduct(); } } } class Consumer extends Thread{ //消费者 private Clerk clerk; public Consumer(Clerk clerk){ this.clerk = clerk; } @Override public void run() { System.out.println("消费者"+ Thread.currentThread().getName() + ":开始消费产品....."); //一顿消费猛如虎 while (true){ try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } clerk.consumerProduct(); } } } 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"); p1.start(); c1.start(); } }
六、JDK5.0新增的线程创建方式（2种）
新增方式一：实现Callable接口创建多线程
//1.创建一个实现Callable接口的实现类 class NumThread implements Callable{ //2.实现call方法，将此线程需要执行的操作声明在call()中 @Override public 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(); } } }
如何理解实现Callable接口的方式创建多线程比实现Runnable接口创建多线程的方式强大？
1.call()可以有返回值。
2.call()可以抛异常，被外面的操作捕获，获取异常信息。
3.Callable是支持泛型的
新增方式二：使用线程池 ------开发中常用
思路：提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用。
package com.atguigu.java2; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.ThreadPoolExecutor; /** * 创建线程的方式四：使用线程池 * * 好处： * 提高响应速度 （减少了创建新线程的时间 * 降低资源消耗 （重复利用线程池中线程，不需要每次都创建 * 便于线程管理 * corePoolSize ：核心池的 大小 * maximumPoolSize ：最大线程 数 * keepAliveTime ：线程没有任务时最多保持多长时间后会 终止 * @author ldbstart * @create 2021-03-06 18:38 */ 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; //设置线程池的属性：ExecutorService是一个接口,不能设置接口中的量哦，要设置它的实现类的值 //System.out.println(service.getClass()); //class java.util.concurrent.ThreadPoolExecutor service1.setCorePoolSize(15); //service1.setKeepAliveTime(); //2.执行指定的线程的操作。需要提供实现Runnable接口或者Callable接口实现类的对象。 service.execute(new NumberThread()); //适合使用于Runnable service.execute(new NumberThread1()); //service.submit();//适合适用于Callable，有返回值，拿FutureTask接收 //3.关闭连接池 service.shutdown(); } }
