文章目录
1.线程同步
线程同步：即当有一个线程在对内存进行操作时，其他线程都不可以对这个内存地址进行操作，直到该线程完成操作， 其他线程才能对该内存地址进行操作，而其他线程又处于等待状态，实现线程同步的方法有很多，临界区对象就是其中一种。
在一般情况下，创建一个线程是不能提高程序的执行效率的，所以要创建多个线程。但是多个线程同时运行的时候可能调用线程函数，在多个线程同时对同一个内存地址进行写入，由于CPU时间调度上的问题，写入数据会被多次的覆盖，所以就要使线程同步。
同步就是协同步调，按预定的先后次序进行运行。如：你说完，我再说。
“同”字从字面上容易理解为一起动作
其实不是，“同”字应是指协同、协助、互相配合。
如进程、线程同步，可理解为进程或线程A和B一块配合，A执行到一定程度时要依靠B的某个结果，于是停下来，示意B运行；B执行，再将结果给A；A再继续操作。
所谓同步，就是在发出一个功能调用时，在没有得到结果之前，该调用就不返回，同时其它线程也不能调用这个方法。按照这个定义，其实绝大多数函数都是同步调用（例如sin, isdigit等）。但是一般而言，我们在说同步、异步的时候，特指那些需要其他部件协作或者需要一定时间完成的任务。例如Window API函数SendMessage。该函数发送一个消息给某个窗口，在对方处理完消息之前，这个函数不返回。当对方处理完毕以后，该函数才把消息处理函数所返回的LRESULT值返回给调用者。
线程同步的前提
(1)多线程状况下;
(2)多个线程去访问同一个资源.
并发和并行:
并行：多个CPU同时执行多个任务。(多个人同时做不同的事).
并发:一个CPU（采用时间片）同时执行多个任务。(多个人做同一件事).
同步的机制: 排队并且加锁
(1)几个线程之间要排队，一个一个对共享资源进行操作，而不是同时进行操作；
(2)为了保证数据在方法中被访问时的正确性，在访问时加入锁机制.
对于初步模拟火车售票:
使用两种创建线程的方式进行比较;
(1)继承Thread类的方式.
ThreadTicket01类模拟;
//模拟售票
public class ThreadTicket01 extends Thread {
//将车票作为共享资源;
static int ticketNum=10;
//重写run方法;
@Override
public void run() {
while(true) {
if (ticketNum > 0) {
//设置进入阻塞状态;
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//售出票;
System.out.println(Thread.currentThread().getName()+"->"+ticketNum);
ticketNum--;
} else {
break;
}
}
}
}
这里的车票用static修饰,全局共享一份资源.
- 被static修饰的变量;随着类的加载而加载.生命周期比较长
- 非static 修饰变量;生命周期与对象相同
测试类:
public class Test1 {
public static void main(String[] args) {
//创建线程1;
ThreadTicket01 t1=new ThreadTicket01();
t1.setName("售票窗口1号");//为线程1设置名称;
//启动线程1;
t1.start();
//创建线程2;
ThreadTicket01 t2=new ThreadTicket01();
t2.setName("售票窗口2号");//为线程2设置名称;
//启动线程2;
t2.start();
}
}
输出结果时:有时会出现同一张票被重复卖出两次或者卖出空票的状况;显然这是不合理的;线程刚失去CPU的执行权,走出运行状态,返回到就绪状态;又再一次获得执行权.
(2)实现Runnable的方式
在这个方式中,多个线程访问了同一个接口的对象,所以车票本身就只有一份,是被共享的,不需要static修饰;
出票的ThreadTicket02类:
//模拟售票
public class ThreadTicket02 implements Runnable{
//在这个方式中,多个线程访问了同一个接口的对象,所以车票本身就只有一份,是被共享的,不需要static修饰;
int ticketNum=10;
//重写run方法;
@Override
public void run() {
while(true){
if(ticketNum>0){
//设置进入阻塞状态;
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//出票;
System.out.println(Thread.currentThread().getName()+"->"+ticketNum);
ticketNum--;
}else{
break;
}
}
}
}
测试类:
public class Tese2 {
public static void main(String[] args) {
//这里只是创建了一个线程执行的任务;
ThreadTicket02 tt=new ThreadTicket02();
//创建线程1;
Thread t1=new Thread(tt,"售票窗口1号");
//启动线程1;
t1.start();
//创建线程2;
Thread t2=new Thread(tt,"售票窗口2号");
//启动线程2;
t2.start();
}
}
同样的,这时的售票也会出现卖出同一张票的情况;
加锁机制
确保一个时间点只有一个线程访问共享资源。可以给共享资源加一把锁，哪个线程获取了这把锁，才有权利访问该共享资源。
可以理解为银行自助取款机的机制,当第一个人进入后,自动上锁;第二个想要进入时发现上锁了,只能等第一个人操作结束,解锁出来后才可以进入取款机操作.
在Java代码中实现线程同步：
- 使用synchronized(同步监视器)关键字同步代码块。
synchronized (同步监视器）{
// 需要被同步的代码；
} - synchronized还可以放在方法声明中，表示整个方法为同步方法。
例如：
public synchronized void show (String name){
// 需要被同步的代码；
}
同步监视器
同步监视器可以是任何对象,必须唯一,保证多个线程获得是同一个对象(锁).
同步监视器的执行过程:
-
第一个线程访问，锁定同步监视器，执行其中代码.
-
第二个线程访问，发现同步监视器被锁定，无法访问.
-
第一个线程访问完毕，解锁同步监视器.
-
第二个线程访问，发现同步监视器没有锁，然后锁定并访问.
使用关键字synchronized (同步监视器）加锁后模拟刚才的火车售票
(1)继承了Thread类的售票方式
使用synchronized(同步监视器)关键字同步代码块。
在刚才的基础上加锁;注意,这里加同步监视器时,不是写在while循环外面;若写到while循环外,则会出现一个线程持续操作,将所有票买完;
为需要同步的代码块,用关键字synchronized (同步监视器)同步代码块修饰;多个线程共同拥有一把锁;谁先获得则先进入,执行任务;其他的线程等待;当持有锁的线程将同步代码块中的内容都执行完后,离开同步代码块,自动释放锁.
//模拟售票
public class ThreadTicket01 extends Thread {
//将车票作为共享资源;
static int ticketNum=10;
//这里使得线程获得的是一个对象(锁);
//这里仍然用static修饰为全局共享的;
static Object object=new Object();
@Override
public void run() {
//注意,这里加同步监视器时,不是写在while循环外面;若写到while循环外,则会出现一个线程持续操作,将所有票买完;
while(true) {
//为需要同步的代码块,用同步代码块修饰;多个线程共同拥有一把锁;谁先获得则先进入,执行任务;其他的线程等待;当持有锁的线程将同步代码块中的内容都执行完后,离开同步代码块,自动释放锁;
synchronized (object) {
if (ticketNum > 0) {
//设置进入阻塞状态;
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//售出票;
System.out.println(Thread.currentThread().getName() + "->" + ticketNum);
ticketNum--;
} else {
break;
}
}
}
}
}
测试类不变;执行后,并没有出现卖出重复的票或者错误的票的情况;
synchronized还可以放在方法声明中，表示整个方法为同步方法。
synchronized修饰方法时,没有创建共享的锁对象;
注意在继承Thread类的方式创建线程时,是创建了多个线程对象,如果没有用static修饰这里的同步方法时,锁对象默认为this;就会出现多个线程拥有多把锁,执行任务时混乱.
所以在继承Thread类的创建线程的方式,需要使用static修饰同步方法.
public class ThreadTicked03 extends Thread{
//将车票作为共享资源;
static int ticketNum=10;
//重写run方法;
@Override
public void run() {
//这里仍然使用死循环;
while(true){
if(ticketNum>0){
printTicket();
}else {
break;
}
}
}
//使用synchronized修饰方法;该方法为同步方法;
//注意这里用static将方法变为全局共享的同一份方法;
public static synchronized void printTicket(){
if (ticketNum > 0) {
//设置进入阻塞状态;
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//售出票;
System.out.println(Thread.currentThread().getName() + "->" + ticketNum);
ticketNum--;
}
}
}
(2)实现Runnable类的售票方式
使用synchronized(同步监视器)关键字同步代码块。
在刚才实现Runnable类的基础上加锁;注意这里在新建锁对象时不需要使用static修饰;
实现Runnable创建线程的方式;只是创建了一个任务,让创建出的多个线程去执行这个任务.
//模拟售票
public class ThreadTicket02 implements Runnable{
//在这个方式中,多个线程访问了同一个接口的对象,所以车票本身就只有一份,是被共享的,不需要static修饰;
int ticketNum=10;
//创建锁对象;
Object object=new Object();
//重写run方法;
@Override
public void run() {
while(true){
//使用synchronized同步代码块;
synchronized (object) {
if (ticketNum > 0) {
//设置进入阻塞状态;
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//出票;
System.out.println(Thread.currentThread().getName() + "->" + ticketNum);
ticketNum--;
} else {
break;
}
}
}
}
}
synchronized还可以放在方法声明中，表示整个方法,为同步方法。
这里的同步方法不需要static修饰.
public class ThreadTicket04 implements Runnable {
//在这个方式中,多个线程访问了同一个接口的对象,所以车票本身就只有一份,是被共享的,不需要static修饰;
int ticketNum=10;
//重写run方法
@Override
public void run() {
//while循环;
while (true) {
if (ticketNum > 0) {
printTicket();
} else {
break;
}
}
}
//使用synchronized修饰方法,为同步方法;
public synchronized void printTicket(){
if (ticketNum > 0) {
//设置进入阻塞状态;
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//出票;
System.out.println(Thread.currentThread().getName() + "->" + ticketNum);
ticketNum--;
}
}
}
死锁
死锁是指两个或两个以上的进程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程。
一种情形，此时执行程序中两个或多个进程发生永久堵塞（等待），每个进程都在等待被其他进程占用并堵塞了的资源。例如，如果进程A锁住了记录1并等待记录2，而进程B锁住了记录2并等待记录1，这样两个进程就发生了死锁现象。
一个线程持有锁时会导致其他所有需要此锁的线程挂起；在多线程模式下，加锁/释放锁会导致比较多的上下文切换和调度延时，引起性能问题.
-
不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步 资源，就形成了线程的死锁.
-
出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续.
不同的线程相互持有对方线程中需要的锁,死锁出现不会报错,不会提示,只是等待.
模拟死锁
//模拟死锁
public class Demo01 extends Thread{
//定义两个锁对象;
static Object object1=new Object();
static Object object2=new Object();
//定义一个标记符;
boolean flag=true;
//构造方法;
public Demo01(Boolean flag){
this.flag=flag;
}
//重写run方法;
@Override
public void run() {
//线程对象传入的flag参数进行分流执行;
if(flag){
synchronized (object1){
System.out.println("if 1号锁");
synchronized (object2){
System.out.println("if 2号锁");
}
}
}else{
synchronized (object2){
System.out.println("else 2号锁");
synchronized (object1){
System.out.println("else 1号锁");
}
}
}
}
}
测试类:
public class Test {
public static void main(String[] args) {
//创建线程1,线程2;
Demo01 demo01=new Demo01(true);
Demo01 demo02=new Demo01(false);
//启动线程1,线程2;
demo01.start();
demo02.start();
}
}
执行,可能会出现死锁现象:例如:
线程一直处于阻塞状态;
当第一个线程进入后,拿到了1号锁;第二个线程进入后拿到了2号锁,但是,这时第一个线程还想继续执行同步代码块中的内容;却获得不到2号锁;第二个线程想要继续执行同步代码块中的内容;由于1号锁被第一个线程拿着;没法获取1号锁.;;所以出现了死锁的状况;既没有异常提示,也没有提示,只是在阻塞状态中等待.
死锁解决方式
在系统中已经出现死锁后，应该及时检测到死锁的发生，并采取适当的措施来解除死锁。
死锁预防
这是一种较简单和直观的事先预防的方法。方法是通过设置某些限制条件，去破坏产生死锁的四个必要条件中的一个或者几个，来预防发生死锁。预防死锁是一种较易实现的方法，已被广泛使用。但是由于所施加的限制条件往往太严格，可能会导致系统资源利用率和系统吞吐量降低。
死锁避免
系统对进程发出的每一个系统能够满足的资源申请进行动态检查，并根据检查结果决定是否分配资源；如果分配后系统可能发生死锁，则不予分配，否则予以分配。这是一种保证系统不进入死锁状态的动态策略。
死锁检测和解除
先检测：这种方法并不须事先采取任何限制性措施，也不必检查系统是否已经进入不安全区，此方法允许系统在运行过程中发生死锁。但可通过系统所设置的检测机构，及时地检测出死锁的发生，并精确地确定与死锁有关的进程和资源。检测方法包括定时检测、效率低时检测、进程等待时检测等。
然后解除死锁：采取适当措施，从系统中将已发生的死锁清除掉。
这是与检测死锁相配套的一种措施。当检测到系统中已发生死锁时，须将进程从死锁状态中解脱出来。常用的实施方法是撤销或挂起一些进程，以便回收一些资源，再将这些资源分配给已处于阻塞状态的进程，使之转为就绪状态，以继续运行。死锁的检测和解除措施，有可能使系统获得较好的资源利用率和吞吐量，但在实现上难度也最大。
- 让程序每次至多只能获得一个锁。当然，在多线程环境下，这种情况通常并不现实。
- 设计时考虑清楚锁的顺序，尽量减少嵌套的加锁交互数量。
Lock锁
从JDK 5.0开始，Java提供了更强大的线程同步机制-通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当。
- java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象。
- ReentrantLock类实现了Lock，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，常用.
Lock锁需要手动加锁,手动关闭锁;如果同步代码块中可能会出现异常,就可以在指定的位置进行关闭释放锁操作,避免异常恶化.
Lock锁的案例
使用方法public abstract void lock( ) 加锁;
使用方法public abstract void unlock( ) 关闭释放锁;
//模拟买票;使用Lock锁;
public class Demo extends Thread{
//定义全局共享变量ticketNum;
static int ticketNum=10;
//定义全局共享的Lock锁对象;
static Lock locks=new ReentrantLock();
//重写run方法;
@Override
public void run() {
while (true){
try{
//lock方法加锁;
locks.lock();
//设置休眠时间;进入阻塞状态;
Thread.sleep(1000);
if(ticketNum>0){
//这里获取当前线程引用的线程名;且售出车票;
System.out.println(Thread.currentThread().getName()+"->"+ticketNum);
ticketNum--;
}else{
break;
}
}catch (Exception e){
//打印异常信息;
e.printStackTrace();
}finally{
//无论是否出现异常,都会手动关闭锁;
//关闭释放锁;
locks.unlock();
}
}
}
}
测试类:
//Lock锁模拟买票的测试类
public class Test {
public static void main(String[] args) {
//创建线程1,线程2,并且命名;
Demo d1=new Demo();
d1.setName("1号窗");
Demo d2=new Demo();
d2.setName("2号窗");
//启动线程1,线程2;
d1.start();
d2.start();
}
}
效果:
Lock锁与synchronized的区别
- lock锁是显示的锁,需要手动加锁,手动关闭释放;(可在指定的位置关闭锁);而synchronized是隐式的锁,当线程执行完同步代码块或者同步方法中的内容后,自动关闭.
- lock锁只能同步代码块,而synchronized可以同步代码块,可以修饰方法为同步方法
- 使用lock锁时JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性（lock是接口,有许多实现子类,常用的实现类为ReentrantLock).
- 在线程的执行优先级中:Lock >同步代码块（已经进入了方法体，分配了相应资源）>同步方法
2.线程通信
线程通信是多个线程之间相互牵制,相互调度执行
通过消息传递的方式.
使用的3个方法
线程通信会用到的三个方法:必须在同步代码块或者是在同步方法(使用synchronized加锁的执行任务)中执行.
-
wait( )方法; 让线程等待 ,进入阻塞状态 ,不会自动唤醒,并且释放同步监视器.
-
notify( )方法; 执行后会唤醒等待的线程(被wait的线程) ;如果有多个在等待,那就唤醒优先级高的线程,
-
notifyAll( ) 方法,唤醒所有等待的线程;
线程通信原理
先回顾一下线程的5种状态:
这里做一份简图:
输出数字的案例实现线程通信
synchronized加锁的实现
线程1和线程2轮流交替输出1-15的数字:
//线程通信案例
public class Demo extends Thread {
//定义全局变量;
static int num=0;
//定义锁对象;
static Object obj=new Object();
//重写run方法;
@Override
public void run() {
while (true) {
//定义同步代码块;
synchronized (obj) {
//唤醒在等待中的线程;
obj.notify();
num++;
if(num<=15){
System.out.println(Thread.currentThread().getName()+"->"+num);
}else{
break;
}
try {
//让线程进入等待状态,且关闭锁;
obj.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
在测试类启动2个线程后;
Lock加锁的实现
注意:和synchronized加锁实现不同,这里需要创建Condition接口的对象;使用的是这个接口的signal方法唤醒等待状态的线程;await方法去让线程进入等待状态的.
线程1和线程2轮流交替输出1-15的数字:
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class Demo01 extends Thread{
//定义全局变量;
static int num=0;
//定义锁;
static Lock look=new ReentrantLock();
//创建Condition接口对象;
static Condition condition=look.newCondition();
//重写run方法;
@Override
public void run() {
while(true){
try{
//加锁;
look.lock();
//唤醒等待状态的线程;
condition.signal();
num++;
if(num<=15){
System.out.println(Thread.currentThread().getName()+"->"+num);
}else{
look.unlock();//关闭锁
break;
}
//让线程进入等待状态,关闭锁;
condition.await();
//关闭锁;
look.unlock();
}catch (Exception e){
e.printStackTrace();//打印异常信息;
look.unlock();//关闭锁;
}
}
}
}
经典生产者,消费者问题
经典例题：生产者/消费者问题
生产者(Productor)将产品放在柜台(Counter)，而消费者(Customer)从柜台处取走产品，生产者一次只能生产固定数量的产品(比如:1）， 这时柜台中不能再放产品,此时生产者应停止生产等待消费者拿走产品,此时生产者唤醒消费者来取走产品,消费者拿走产品后,唤醒生产者,消费者开始等待.
生产者和消费者作为两个不同的线程对于同一个共享的数据(商品数量)进行操作.
创建柜台类:存放共享数据;(商品的数量)
//柜台类,存放共享数据;
public class Counter {
//共享数据;商品的数量;
int num=0;
//生产商品的同步方法;
public synchronized void add(){
if(num==0){
num++;
System.out.println("生产商品");
//唤醒消费者线程;
this.notify();
}else{
try {
//让生产者线程等待;
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
//消费拿走商品的同步方法;
public synchronized void sub(){
if(num==1){
num--;
System.out.println("消费商品");
//唤醒生产者线程
this.notify();
}else{
try {
//让消费者线程等待;
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
创建生产者线程:
//生产者线程;
public class Productor extends Thread {
Counter counter;
//构造方法,传入柜台类的参数;
public Productor(Counter counter){
this.counter=counter;
}
//重写run方法;
@Override
public void run() {
while(true){
//设置休眠,让线程进入阻塞状态;
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//调用生产商品的方法;
counter.add();
}
}
}
创建消费者线程:
//消费者线程
public class Customer extends Thread{
Counter counter;
//构造方法,传入柜台类的参数;
public Customer(Counter counter){
this.counter=counter;
}
//重写run方法;
@Override
public void run() {
while(true){
//设置休眠,让线程进入阻塞状态;
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//调用消费商品的方法;
counter.sub();
}
}
}
测试类:
//测试类
public class Test {
public static void main(String[] args) {
//这里创建柜台类的对象;
Counter counter=new Counter();
//创建生产者线程对象;
Productor pro=new Productor(counter);
//创建消费者线程对象;
Customer cus=new Customer(counter);
//启动线程;
pro.start();
cus.start();
}
}
执行效果:
3.新增的创建线程方式
3.1实现Callable接口的方式
- 实现Callable接口;这个接口是支持泛型的,不写时默认为Object类;
- 需要重写call( )方法;这个方法支持声明抛出异常且该方法有返回值;
- 由于FutureTask类底层实现了Runnable;所以需要使用这个类来传入要执行的任务对象;FutureTask类也支持使用泛型,最终还需要使用FutureTask类的get方法来获得返回结果.
案例:
import java.util.concurrent.Callable;
//实现Callable接口;这个接口是支持泛型的,不写时默认为Object类;
public class Thread03 implements Callable <Integer>{
//重写call()方法;这个方法支持声明抛出异常;
@Override
public Integer call() throws Exception {
int number=0;
for (int i = 1; i <= 20; i++) {
number+=i;
}
return number;
}
}
测试类:
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
//实现Callable接口创建线程的测试类;
public class Test {
public static void main(String[] args) {
//创建一个任务;
Thread03 thread03=new Thread03();
//使用FutureTask接收任务;
//这个方法底层实现了Runnable;
//FutureTask类也支持使用泛型;
FutureTask<Integer> ft=new FutureTask(thread03);
//创建线程对象;
Thread thread=new Thread(ft,"线程:");
//启动线程;
thread.start();
try {
//需要使用FutureTask的get方法获取返回的结果;
Integer integer=ft.get();
System.out.println(integer);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}
效果:
3.2使用线程池的方式
线程池（英语：thread pool）：一种线程使用模式。线程过多会带来调度开销，进而影响缓存局部性和整体性能。而线程池维护着多个线程，等待着监督管理者分配可并发执行的任务。这避免了在处理短时间任务时创建与销毁线程的代价。线程池不仅能够保证内核的充分利用，还能防止过分调度。可用线程数量应该取决于可用的并发处理器、处理器内核、内存、网络sockets等的数量。 例如，线程数一般取cpu数量+2比较合适，线程数过多会导致额外的线程切换开销。
任务调度以执行线程的常见方法是使用同步队列，称作任务队列。池中的线程等待队列中的任务，并把执行完的任务放入完成队列中。
线程池模式一般分为两种：HS/HA半同步/半异步模式、L/F领导者与跟随者模式。
半同步/半异步模式又称为生产者消费者模式，是比较常见的实现方式，比较简单。分为同步层、队列层、异步层三层。同步层的主线程处理工作任务并存入工作队列，工作线程从工作队列取出任务进行处理，如果工作队列为空，则取不到任务的工作线程进入挂起状态。由于线程间有数据通信，因此不适于大数据量交换的场合。
领导者跟随者模式，在线程池中的线程可处在3种状态之一：领导者leader、追随者follower或工作者processor。任何时刻线程池只有一个领导者线程。事件到达时，领导者线程负责消息分离，并从处于追随者线程中选出一个来当继任领导者，然后将自身设置为工作者状态去处置该事件。处理完毕后工作者线程将自身的状态置为追随者。这一模式实现复杂，但避免了线程间交换任务数据，提高了CPU cache相似性。在ACE(Adaptive Communication Environment)中，提供了领导者跟随者模式实现。
线程池的伸缩性对性能有较大的影响。
创建太多线程，将会浪费一定的资源，有些线程未被充分使用。
销毁太多线程，将导致之后浪费时间再次创建它们。
创建线程太慢，将会导致长时间的等待，性能变差。
销毁线程太慢，导致其它线程资源饥饿。
由于经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对程序的性能影响很大。
使用线程池创建线程的前提
事先将创建的多个线程放入线程池中,使用时直接调用;使用完后又放回池中;可以避免频繁创建销毁、实现重复利用。降低了资源的消耗,便于线程管理.
类似于别的类里面的池,起到一个缓冲的作用,减少创建的次数,提升效率.
在JDK 5.0开始提供线程池相关API
线程池的接口 :ExecutorService;
常用的子类ThreadPoolExecutor;
对于实现了Runnable接口的创建线程;使用方法void execute(Runnable command）执行任务;
对于实现了Callable接口的创建线程;使用方法 Future submit（Callable task）执行任务.
使用方法void shutdown( )关闭线程池;
Executors：线程池的工具类，用于创建并返回不同类型的线程池.
- Executors.newCachedThreadPool（ )创建一个可根据需要创建新线程的线程池.
- Executors.newFixedThreadPool （ )创建一个可重用固定线程数的线程池
- Executors.newSingleThreadExecutor（ ）创建一个只有一个线程的线程池
- Executors.newScheduledThreadPool（n）创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行。
写一个线程池创建线程的案例;
这里使用上面实现Callable接口的线程案例:
import java.util.concurrent.Callable;
//实现Callable接口;这个接口是支持泛型的,不写时默认为Object类;
public class Thread03 implements Callable <Integer>{
//重写call()方法;这个方法支持声明抛出异常;
@Override
public Integer call() throws Exception {
int number=0;
//获取正在执行的线程名;
System.out.println(Thread.currentThread().getName());
for (int i = 1; i <= 20; i++) {
number+=i;
}
return number;
}
}
测试类:
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
//线程池学习的测试类;
public class Test1 {
public static void main(String[] args) {
//创建任务;
Thread03 thread03=new Thread03();
//创建线程数为4的线程池;
ExecutorService executorService=Executors.newFixedThreadPool(4);
//对于实现Callable接口创建的线程;
//使用submit方法;
//这里写6个线程;但是线程池只有4个空间;
//线程池会重复利用;
executorService.submit(thread03);
executorService.submit(thread03);
executorService.submit(thread03);
executorService.submit(thread03);
executorService.submit(thread03);
executorService.submit(thread03);
//关闭线程池;
executorService.shutdown();
}
}
执行:这里体现了线程池重复利用的特点.
239
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
