JavaEE进阶知识学习----多线程JUC知识学习
多线程基础知识
1.概述程序，进程和线程
程序：是为了完成某一特定的功能或任务，用某种语言编写的一段静态代码。
进程：是程序的一次执行过程，它自身有产生，存在和消亡的生命周期。
线程：是进程的小单元，是一个程序内部的一条执行路径。
多线程的创建和使用
创建方法一
继承Thread类，重写Run()方法
使用说明：
- 定义子类继承Thread类。
- 子类中重写Thread类中的run方法。
- 创建Thread子类对象，即创建了线程对象
- 调用线程对象的start方法，启动线程，调用run方法。
class SubThread extends Thread{
@Override
public void run() {
for(int i = 1; i <=100;i++){
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}
public class TestThread {
public static void main(String[] args) {
SubThread st = new SubThread();
st.start();
for(int i = 1; i <=100;i++){
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}Thread类常用方法说明
- start(),启动线程并执行相应的run()方法。
- run(),子线程要执行的代码放在run()方法中。
- currentThread(),静态方法，调取当前的线程。
- getName(),获取此线程的名字。
- setName(),设置此线程的名字。
- yield(),调用此方法的线程释放当前cpu的执行权。
以上方法的测试代码如下：
class SubThread extends Thread{
@Override
public void run() {
for(int i = 1; i <=100;i++){
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}
public class TestThread {
public static void main(String[] args) {
SubThread st = new SubThread();
st.setName("我是子线程");
st.start();
Thread.currentThread().setName("我是主线程======");
for(int i = 1; i <=100;i++){
System.out.println(Thread.currentThread().getName()+":"+i);
if(i % 10 == 0){
Thread.currentThread().yield();
}
}
}
}- join(),在A线程中调用B线程的join()方法，表示A线程执行到此方法，A线程停止执行，直到B线程执行结束，在执行A线程剩余的。
- isAlive(),判断线程是否还存活。
- sleep(long long),显示的让当前线程睡眠long毫秒。
class SubThread extends Thread{
@Override
public void run() {
for(int i = 1; i <=100;i++){
try {
Thread.currentThread().sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}
public class TestThread {
public static void main(String[] args) {
SubThread st = new SubThread();
st.setName("我是子线程");
st.start();
Thread.currentThread().setName("我是主线程======");
for(int i = 1; i <=100;i++){
System.out.println(Thread.currentThread().getName()+":"+i);
if(i == 20){
try {
st.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
System.out.println(st.isAlive());
}
}- 线程通信：wait(),notify(),notifyAll()
- getPriority()，返回线程的优先值。
- setPriority(int newPriority),改变线程的优先级。
继承方式实例
模拟火车站售票窗口，开启三个窗口售票，总票数为100张
class Window extends Thread{
static int ticket = 100;
public void run() {
while(true){
if(ticket > 0){
System.out.println(Thread.currentThread().getName()+":"+ticket--);
}else{
break;
}
}
}
}
public class ThreadDemo {
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();
}
}注意：ticket只有声明为static,因为三个线程是三个对象，如果不声明为static，三个线程对象就会各自拥有一个ticket=100，使用static修饰后，三个对象共用一个ticket=100。
创建方法二
实现Runnable接口
- 定义子类，实现Runnable接口。
- 子类重写Runnable接口中的run方法。
- 通过Thread类含参构造器创建线程对象。
- 将Runnable接口的子类对象作为实际参数传递给Thread类的构造方法中。
- 调用Thread类的start方法，开启线程并调用Runnable子类的run方法。
class RunnableDemo implements Runnable{
@Override
public void run() {
for(int i = 1 ; i <= 100; i++){
if(i % 2 ==0){
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}
}
public class TestRunnable {
public static void main(String[] args) {
RunnableDemo ra = new RunnableDemo();
Thread t1 = new Thread(ra);
t1.start();
Thread t2 = new Thread(ra);
t2.start();
}
}实现方式实例
class RunnableDemo implements Runnable{
int ticket = 100;
@Override
public void run() {
while(true){
if(ticket > 0){
System.out.println(Thread.currentThread().getName()+":"+ticket--);
}else{
break;
}
}
}
}
public class TestRunnable {
public static void main(String[] args) {
RunnableDemo ra = new RunnableDemo();
Thread t1 = new Thread(ra);
Thread t2 = new Thread(ra);
Thread t3 = new Thread(ra);
t1.setName("窗口一");
t2.setName("窗口二");
t3.setName("窗口三");
t1.start();
t2.start();
t3.start();
}
}继承和实现
联系和区别
区别：
继承：线程代码存放在Thread子类的run方法中。
实现：线程代码存放在接口的子类的run方法中。
实现的好处：
- 避免了单继承的局限性
- 多个线程可以共享同一个接口的实现类的对象，适合多个线程来处理同一份资源。
线程的调度
调度策略
时间片：就是按时间顺序，先到先执行。
抢占式：高高优先级的线程抢占CPU。
调度方法
1.同优先级线程组成先进先出队列，使用时间片策略。
2.对高优先级，使用优先调度的抢占式策略。
线程的优先级
MAX_PRIORITY（10）; 最大的优先级
MIN _PRIORITY （1）; 最小的优先级
NORM_PRIORITY （5）; 默认的优先级
getPriority()，返回线程的优先值。
setPriority(int newPriority),改变线程的优先级。
线程的创建时继承父线程的优先级。
优先级别只是说线程抢占CPU的概率增加，并不能说是一定高优先级的先执行完。
线程的生命周期
JDK中用Thread.State枚举表示线程的几种状态。
- 新建： 当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态
- 就绪：处于新建状态的线程被start()后，将进入线程队列等待CPU时间片，此时它已具备了运行的条件
- 运行：当就绪的线程被调度并获得处理器资源时,便进入运行状态， run()方法定义了线程的操作和功能
- 阻塞：在某种特殊情况下，被人为挂起或执行输入输出操作时，让出 CPU 并临时中止自己的执行，进入阻塞状态
- 死亡：线程完成了它的全部工作或线程被提前强制性地中止
线程的同步机制
在上面使用继承和实现方法的案例中，有时运行会出现一种情况重票，和负票的情况。这个就是线程安全问题。
线程安全问题原因
我们创建了多个线程，存在共享数据，那就有可能出现线程安全问题，当其中一个线程操作共享数据时，还未操作完成 ，另外的线程参与进来，导致对共享数据的操作出现问题。
解决方法
要求一个线程操作共享数据结束后，其他线程才能参与进来。
方式一：同步代码块
synchronized(同步监视器){
//需要被同步的代码块（即为操作共享数据的代码）
}共享数据：多个线程共同操作的同一数据（变量）。
同步监视器：由一个类的对象来充当，那个线程获取此监视器，谁就执行大括号里面被同步的代码。俗称锁，任何一个类的对象都可以充当锁，要想保证线程的安全，就必须要求所有的线程共用一把锁。（如果将锁放在run方法里，就成了局部变量，就不会保证线程安全）
使用实现的方式中，同步监视器可以使用this，继承的的方式慎用this。
class RunnableDemo implements Runnable{
int ticket = 100;//共享数据
@Override
public void run() {
while(true){
synchronized(this){
if(ticket > 0){
System.out.println(Thread.currentThread().getName()+":"+ticket--);
}
}
}
}
}
public class TestRunnable {
public static void main(String[] args) {
RunnableDemo ra = new RunnableDemo();
Thread t1 = new Thread(ra);
Thread t2 = new Thread(ra);
Thread t3 = new Thread(ra);
t1.setName("窗口一");
t2.setName("窗口二");
t3.setName("窗口三");
t1.start();
t2.start();
t3.start();
}
}在继承方式中，锁只有声明为static才能保证线程安全，
方式二：同步方法
将操作共享数据的方法声明为synchronized，即表明此方法为同步方法。
class RunnableDemo implements Runnable{
int ticket = 100;//共享数据
@Override
public void run() {
while(true){
show();
}
}
public synchronized void show(){
if(ticket > 0){
try {
Thread.currentThread().sleep(10);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+":"+ticket--);
}
}
}
public class TestRunnable {
public static void main(String[] args) {
RunnableDemo ra = new RunnableDemo();
Thread t1 = new Thread(ra);
Thread t2 = new Thread(ra);
Thread t3 = new Thread(ra);
t1.setName("窗口一");
t2.setName("窗口二");
t3.setName("窗口三");
t1.start();
t2.start();
t3.start();
}
}同步方法的锁：就时当前对象this。在继承方式中不能使用，因为锁代表当前对象。继承的方式有多个对象。
互斥锁
在Java语言中，为了保证共享数据操作的完整性，引入了对象互斥锁的概念。
每一个对象都对应于一个可称为“互斥锁”的标记，这个标记用来保证在任一时刻，只有一个线程访问改对象。
关键字synchronized来与对象的互斥锁联系，当某一个对象用synchronized修饰时，表明改对象在任一时刻只能由一个线程访问。
同步的局限性会导致程序的执行效率降低。
多线程的优点
概述
- 提高应用程序的响应，增强用户体验。
- 提高计算机系统的CPU利用率。
- 改善程序结构，将既长又复杂的进程分为多个线程，独立运行，利于修改和理解。
Lock同步锁
概述
解决线程安全问题的方式，使用synchronize隐式锁，1.同步代码块，2.同步方法，3.java5之后使用同步锁Lock：显示锁，也就是说必须通过lock()方法上锁，通过unlock()方法释放锁。
实例
public class TestLock {
public static void main(String[] args) {
Ticket ticket = new Ticket();
new Thread(ticket, "1号窗口").start();
new Thread(ticket, "2号窗口").start();
new Thread(ticket, "3号窗口").start();
}
}
class Ticket implements Runnable {
private int tick = 100;
private Lock lock = new ReentrantLock();
@Override
public void run() {
while (true) {
lock.lock();// 上锁
try {
if (tick > 0) {
try {
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()
+ "完成售票，余票为：" + --tick);
}
} finally {
lock.unlock();//释放锁，那必须写在finally中
}
}
}
}使用lock如何实现等待-唤醒机制，实例为生产者消费者案例
虚假唤醒
在生产者和消费者中，生产者向店员提供商品，消费者向店员消费商品，在多个线程中同时生产和消费，就会出现一种情况就是不停的显示缺货，为了解决这个问题就是，如果店员没有商品，那么消费者消费的线程就等待，否则就唤醒，同理，生产者发现店员商品已满就等待生产，否则就唤醒生产，虚假唤醒就是一些obj.wait()会在除了obj.notify()和obj.notifyAll()的其他情况被唤醒，而此时是不应该唤醒的。以下是一种解决办法：
public class TestProductorAndCosumer {
public static void main(String[] args) {
Clerk clerk = new Clerk();
Productor productor = new Productor(clerk);
Customer customer = new Customer(clerk);
new Thread(productor,"生产者 A").start();
new Thread(customer,"消费者 B").start();
new Thread(productor,"生产者 C").start();
new Thread(customer,"消费者 D").start();
}
}
//店员
class Clerk{
private int product = 0;
//进货
public synchronized void get(){
while(product >= 1){// 为了避免虚假唤醒的问题，应该使用在循环中
System.out.println("产品已满！！");
try {
this.wait();//产品已满，等待消费者的通知
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(Thread.currentThread().getName()+" : "+ ++product);
this.notifyAll();
}
//卖货
public synchronized void sale(){
while(product <= 0){
System.out.println("缺货！！");
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(Thread.currentThread().getName()+" : "+ --product);
this.notifyAll();
}
}
//生产者
class Productor implements Runnable{
private Clerk clerk;
public Productor(Clerk clerk){
this.clerk = clerk;
}
@Override
public void run() {
for (int i = 0; i < 20; i++) {
try {
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
clerk.get();//20个员工不断生产商品给店员
}
}
}
//消费者
class Customer implements Runnable{
private Clerk clerk;
public Customer(Clerk clerk) {
this.clerk = clerk;
}
@Override
public void run() {
for (int i = 0; i < 20; i++) {
clerk.sale();
}
}
}结果如下：
缺货！！
缺货！！
生产者 A : 1
消费者 D : 0
缺货！！
缺货！！
生产者 C : 1
消费者 B : 0
缺货！！
缺货！！
生产者 A : 1
消费者 D : 0
缺货！！
缺货！！
生产者 C : 1
消费者 B : 0
缺货！！
缺货！！
生产者 A : 1
消费者 D : 0
缺货！！
生产者 C : 1
消费者 B : 0解决办法之二：使用Lock锁
public class TestProductorAndCosumerforLock {
public static void main(String[] args) {
Clerk clerk = new Clerk();
Productor productor = new Productor(clerk);
Customer customer = new Customer(clerk);
new Thread(productor,"生产者 A").start();
new Thread(customer,"消费者 B").start();
new Thread(productor,"生产者 C").start();
new Thread(customer,"消费者 D").start();
}
}
//店员
class Clerk{
private int product = 0;
private Lock lock = new ReentrantLock();
private Condition condition = lock.newCondition();
//进货
public void get(){
lock.lock();
try {
while(product >= 1){// 为了避免虚假唤醒的问题，应该使用在循环中
System.out.println("产品已满！！");
try {
condition.await();//产品已满，等待消费者的通知
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(Thread.currentThread().getName()+" : "+ ++product);
condition.signalAll();
}finally{
lock.unlock();
}
}
//卖货
public void sale(){
lock.lock();
try {
while(product <= 0){
System.out.println("缺货！！");
try {
condition.await();;
} catch (InterruptedException e) {
}
}
System.out.println(Thread.currentThread().getName()+" : "+ --product);
condition.signalAll();
}finally{
lock.unlock();
}
}
}
//生产者
class Productor implements Runnable{
private Clerk clerk;
public Productor(Clerk clerk){
this.clerk = clerk;
}
@Override
public void run() {
for (int i = 0; i < 3; i++) {
try {
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
clerk.get();//20个员工不断生产商品给店员
}
}
}
//消费者
class Customer implements Runnable{
private Clerk clerk;
public Customer(Clerk clerk) {
this.clerk = clerk;
}
@Override
public void run() {
for (int i = 0; i < 3; i++) {
clerk.sale();
}
}
}注意上述代码中改动的地方有很多，使用了接下来要说的Condition控制线程通信
Condition控制线程通信
在上述代码中也使用了Condition控制线程通信，Condition接口描述了可能会与锁有关联的条件变量，在Condition对象中与wait、notify、notifyAll方法分别对应的是await、signal、signalAll。
面试题
编写一个程序，开启三个线程，这三个线程的ID分别为A、B、C，每一个线程将自己的ID打印10遍，输出结果为
ABBCCCABBCCC….依次递归
public class TestABC {
public static void main(String[] args) {
final AlternateDemo ad = new AlternateDemo();
new Thread(new Runnable() {
@Override
public void run() {
for (int i = 1; i <= 10; i++) {
ad.loopA(i);
}
}
},"A").start();
new Thread(new Runnable() {
@Override
public void run() {
for (int i = 1; i <= 10; i++) {
ad.loopB(i);
}
}
},"B").start();
new Thread(new Runnable() {
@Override
public void run() {
for (int i = 1; i <= 10; i++) {
ad.loopC(i);
System.out.println("================一轮结束==================");
}
}
},"C").start();
}
}
class AlternateDemo{
private int number = 1;// 当前正在执行线程的标记
private Lock lock = new ReentrantLock();
private Condition condition1 = lock.newCondition();
private Condition condition2 = lock.newCondition();
private Condition condition3 = lock.newCondition();
public void loopA(int totalLoop){
lock.lock();
try {
if(number != 1){
condition1.await();
}
//打印
for(int i = 1; i <= 1; i++){
System.out.println(Thread.currentThread().getName()+"\t"+i+"\t"+totalLoop);
}
//唤醒别人
number = 2;
condition2.signal();//只唤醒线程B
} catch (Exception e) {
e.printStackTrace();
}finally{
lock.unlock();
}
}
public void loopB(int totalLoop){
lock.lock();
try {
if(number != 2){
condition2.await();
}
//打印
for(int i = 1; i <= 2; i++){
System.out.println(Thread.currentThread().getName()+"\t"+i+"\t"+totalLoop);
}
//唤醒别人
number = 3;
condition3.signal();//只唤醒线程C
} catch (Exception e) {
e.printStackTrace();
}finally{
lock.unlock();
}
}
public void loopC(int totalLoop){
lock.lock();
try {
if(number != 3){
condition3.await();
}
//打印
for(int i = 1; i <= 3; i++){
System.out.println(Thread.currentThread().getName()+"\t"+i+"\t"+totalLoop);
}
//唤醒别人
number = 1;
condition1.signal();//只唤醒线程A
} catch (Exception e) {
e.printStackTrace();
}finally{
lock.unlock();
}
}
}ReadWriteLock读写锁
概述
说明：写写/读写需要‘互斥’，读读不需要‘互斥’。不能一存在线程问题就加锁，读就不需要锁，所以才有了读写分离的读写锁ReadWriteLock。
是一个接口，位于java.util.concurrent.locks包下。有两个方法
Lock readLock() 返回用于读取操作的锁。
Lock writeLock() 返回用于写入操作的锁。
实例
public class TestReadWriteLock {
public static void main(String[] args) {
final ReadWriteLockDemo rw = new ReadWriteLockDemo();
new Thread(new Runnable() {
@Override
public void run() {
rw.set((int)(Math.random()*10));
}
},"写线程").start();
for(int i = 0; i< 5; i++){
new Thread(new Runnable() {
@Override
public void run() {
rw.get();
}
},"读操作").start();
}
}
}
class ReadWriteLockDemo{
private int number = 0;
private ReadWriteLock lock = new ReentrantReadWriteLock();
//读操作
public void get(){
lock.readLock().lock();//上锁
try{
System.out.println(Thread.currentThread().getName()+":"+number);
}finally{
lock.readLock().unlock();//释放锁
}
}
//写操作
public void set(int number){
lock.writeLock().lock();
try{
System.out.println(Thread.currentThread().getName());
this.number = number;
}finally{
lock.writeLock().unlock();
}
}
}线程八锁
如下实例：
两个普通同步方法，两个线程，标准打印，结果：one two
public class TestThread8Monitor {
public static void main(String[] args) {
final Number number = new Number();
new Thread(new Runnable() {
@Override
public void run() {
number.getOne();
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
number.getTwo();
}
}).start();
}
}
class Number{
public synchronized void getOne(){
System.out.println("one");
}
public synchronized void getTwo(){
System.out.println("Two");
}
}新增Thread.sleep()给getOne(),结果：one two
public class TestThread8Monitor {
public static void main(String[] args) {
final Number number = new Number();
new Thread(new Runnable() {
@Override
public void run() {
number.getOne();
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
number.getTwo();
}
}).start();
}
}
class Number{
public synchronized void getOne(){
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("one");
}
public synchronized void getTwo(){
System.out.println("Two");
}
}新增普通方法getThree(),结果：three one two
public class TestThread8Monitor {
public static void main(String[] args) {
final Number number = new Number();
new Thread(new Runnable() {
@Override
public void run() {
number.getOne();
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
number.getTwo();
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
number.getThree();
}
}).start();
}
}
class Number{
public synchronized void getOne(){
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("one");
}
public synchronized void getTwo(){
System.out.println("Two");
}
public void getThree(){
System.out.println("Three");
}
}两个普通同步方法，两个对象，结果：two one
public class TestThread8Monitor {
public static void main(String[] args) {
final Number number1 = new Number();
final Number number2 = new Number();
new Thread(new Runnable() {
@Override
public void run() {
number1.getOne();
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
number2.getTwo();
}
}).start();
}
}
class Number{
public synchronized void getOne(){
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("one");
}
public synchronized void getTwo(){
System.out.println("Two");
}
}修改getOne()为静态同步方法，结果：two one
public class TestThread8Monitor {
public static void main(String[] args) {
final Number number1 = new Number();
final Number number2 = new Number();
new Thread(new Runnable() {
@Override
public void run() {
number1.getOne();
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
number2.getTwo();
}
}).start();
}
}
class Number{
public static synchronized void getOne(){
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("one");
}
public synchronized void getTwo(){
System.out.println("Two");
}
}修改两个方法均为静态同步方法，一个对象，结果：one two
public class TestThread8Monitor {
public static void main(String[] args) {
final Number number1 = new Number();
new Thread(new Runnable() {
@Override
public void run() {
number1.getOne();
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
number1.getTwo();
}
}).start();
}
}
class Number{
public static synchronized void getOne(){
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("one");
}
public static synchronized void getTwo(){
System.out.println("Two");
}
}一个静态同步方法，一个非静态同步方法，两个对象，结果：two one
public class TestThread8Monitor {
public static void main(String[] args) {
final Number number1 = new Number();
final Number number2 = new Number();
new Thread(new Runnable() {
@Override
public void run() {
number1.getOne();
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
number2.getTwo();
}
}).start();
}
}
class Number{
public static synchronized void getOne(){
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("one");
}
public synchronized void getTwo(){
System.out.println("Two");
}
}两个静态同步方法，两个对象，结果：one two
public class TestThread8Monitor {
public static void main(String[] args) {
final Number number1 = new Number();
final Number number2 = new Number();
new Thread(new Runnable() {
@Override
public void run() {
number1.getOne();
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
number2.getTwo();
}
}).start();
}
}
class Number{
public static synchronized void getOne(){
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("one");
}
public static synchronized void getTwo(){
System.out.println("Two");
}
}以上就是线程的八种常见的情况，线程八锁的关键在于：
- 非静态方法的锁默认为this，静态方法的锁为对应的class实例（这里是NUmber.class）
- 某一个时刻内，只能有一个线程持有锁，无论有几个方法
线程池
先看一个简单的实例
public class TestThreadPool {
public static void main(String[] args) {
ThreadPoolDemo td = new ThreadPoolDemo();
new Thread(td).start();
new Thread(td).start();
new Thread(td).start();
}
}
class ThreadPoolDemo implements Runnable{
private int i = 0;
@Override
public void run() {
while (i<= 100) {
System.out.println(Thread.currentThread().getName());
}
}
}上面我们就是创建和销毁了三个线程实例，这样不断的创建和销毁，就会消耗资源，于是就出现了线程池，和数据库连接池一样，就是有许多的线程已经创建好了，我们直接使用就好。
线程池：提供了一个线程队列，队列中保存着所有等待状态的线程，避免了创建与销毁额外的开销，提高了响应的性能。
线程池的体系结构
java.util.concurrent.Executor:负责线程的使用与调度的根接口
一个 ExecutorService，它使用可能的几个池线程之一执行每个提交的任务，通常使用 Executors 工厂方法配置。
线程池可以解决两个不同问题：由于减少了每个任务调用的开销，它们通常可以在执行大量异步任务时提供增强的性能，并且还可以提供绑定和管理资源（包括执行任务集时使用的线程）的方法。每个 ThreadPoolExecutor 还维护着一些基本的统计数据，如完成的任务数。
工具类Executor
- ExecutorService newFixedThreadPool(int nThreads) 创建一个可重用固定线程数的线程池，以共享的无界队列方式来运行这些线程。
- ExecutorService newCachedThreadPool() 创建一个可根据需要创建新线程的线程池
- static ExecutorService newSingleThreadExecutor() 创建一个使用单个 worker 线程的 Executor
- static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) 创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行。
线程池使用
public class TestThreadPool {
public static void main(String[] args) {
// 1.创建线程池
ExecutorService pool = Executors.newFixedThreadPool(5);//创建了5个线程的线程池
ThreadPoolDemo td = new ThreadPoolDemo();
// 2.为线程池中的线程分配任务
for (int i = 0; i < 10; i++) {
pool.submit(td);
}
// 3.关闭线程池
pool.shutdown();
}
}
class ThreadPoolDemo implements Runnable{
private int i = 0;
@Override
public void run() {
while (i<= 5) {
System.out.println(Thread.currentThread().getName()+":"+i++);
}
}
}使用Callable创建线程的方式
public class TestThreadPool {
public static void main(String[] args) throws InterruptedException, ExecutionException {
// 1.创建线程池
ExecutorService pool = Executors.newFixedThreadPool(5);//创建了5个线程的线程池
List> list = new ArrayList>();
for (int i = 0; i < 10; i++) {
Future future = pool.submit(new Callable() {
@Override
public Integer call() throws Exception {
int sum = 0;
for (int i = 0; i < 100; i++) {
sum +=i;
}
return sum;
}
});
list.add(future);
}
// 3.关闭线程池
pool.shutdown();
for (Future future: list) {
System.out.println(future.get());
}
}
} 线程调度
在线程池中提到了一个ScheduledExecutorService这一个类就是用来实现线程的调度的。
实例
public class TestScheduledThread {
public static void main(String[] args) throws InterruptedException, ExecutionException {
ScheduledExecutorService pool = Executors.newScheduledThreadPool(5);// 创建五个线程的线程池
for (int i = 0; i < 5; i++) {
ScheduledFuture result = pool.schedule(new Callable() {
@Override
public Integer call() throws Exception {
int num = new Random().nextInt(100);//产生随机数
System.out.println(Thread.currentThread().getName()+":"+num);
return num;
}
}, 3, TimeUnit.SECONDS);
System.out.println(result.get());
}
pool.shutdown();
}
} Fork/Join框架
概述
Fork/Join框架就是在必要的情况下，将一个大任务，进行拆分（fork）成若干个小任务（拆到不可再拆为止，即临界值），再将一个个的小任务运算的结果进行join汇总，这里要说明的是拆分和合并也需要时间，例如求100的累加和，可以使用for循环直接累加，也可以使用Fork/Join,但是执行时间反而是for循环要快的多，如果要计算100000000就是Fork/Join要快的多，所以包括临界值的设定都要不停的测试得出，
实例
public class TestForkJoinPool {
public static void main(String[] args) {
ForkJoinPool pool = new ForkJoinPool();
ForkJoinTask task = new ForkJoinSum(0L, 1000000L);
long sum = pool.invoke(task);
System.out.println(sum);
}
}
class ForkJoinSum extends RecursiveTask{
private static final long serialVersionUID = 1L;
private long start;
private long end;
private static final long THURSHOLD = 10000L;// 临界值
public ForkJoinSum(long start,long end) {
this.start = start;
this.end = end;
}
@Override
protected Long compute() {
long length = end -start;
if(length <= THURSHOLD){
long sum = 0L;
for(long i = start; i<= end;i++){
sum +=i;
}
return sum;
}else{
long middle = (end+start) / 2;
ForkJoinSum left = new ForkJoinSum(start, middle);//递归操作
left.fork();// 进行拆分，同时压入线程队列
ForkJoinSum right = new ForkJoinSum(middle+1, end);
right.fork();
return left.join()+right.join();
}
}
}