1 概念
操作系统的基本特征包括并发、共享、虚拟和异步。
1.并发
操作系统的并发性是指计算机系统中同时存在多个运行着的程序,因此它具有处理和调度多个程序同时执行的能力,引入进程的目的是使程序能并发执行。
并发:指两个事件或多个事件在同一个时间段内发生。
并行:指两个或多个事件在同一时刻发生(同时发生)。
2.共享
资源共享即共享,是指系统中的资源可供内存中多个并发执行的进程共同使用,共享可分为以下两种资源共享方式。
(1)互斥共享方式
当进程A访问某资源时,必须先提出请求,如果此时资源空闲,系统便可以将之分配给进程A使用,此后若有其他进程也要访问该资源时(A未使用完),则必须等待。仅当A资源访问完并释放资源后,才允许另一进程对该资源进行访问。在一段时间内只允许一个进程访问的资源成为临界资源或独占资源。
例如打印机、磁带机等。
(2)同时访问方式
系统中还有另一类资源,允许在一段时间内由多个进程“同时”(宏观的同时,微观上交替访问)对它们进行访问,例如磁盘设备。
3.虚拟
虚拟是指把一个物理上的实体变为若干个逻辑上的对应物。
4.异步
在多道程序环境下,允许多个程序并发执行,但由于资源有限,进程的执行不是一贯到底,而是走走停停,以不可预知的速度向前推进,这就是进程的异步性。
5.进程
是指一个内存中运行的应用程序,每个进程都有一个独立的内存空间,一个应用程序可以同时运行多个进程;进程也是程序的一次执行过程,是系统运行程序的基本单位;系统运行一个程序从创建、运行到消亡的过程。
6.线程
线程是进程中的一个执行单元,负责当前进程中程序的执行,一个进程中至少有一个线程。一个进程中是可以有多个线程的,这个应用程序也可以称之为多线程程序。
简而言之:一个程序运行至少有一个进程,一个进程中包含有多个线程。
7.线程调度
(1)分时调度
所有线程轮流使用CPU的使用权,平均分配每个线程占用CPU的时间。
(2)抢占式调度
优先让优先级高的线程使用CPU,如果线程的优先级相同,那么会随机选择一个,Java使用的为抢占式调度。
8.多线程
多进程是指操作系统能同时运行多个任务(程序),多线程是指在同一程序中有多个顺序流在执行。
多线程内存图如下:
Java使用java.lang.Thread
类代表线程,所有的线程对象都必须是Thread类或其子类的实例。每个线程的作用是完成一定的任务,实际上就是执行一段程序流即一段顺序执行的代码。Java使用线程执行体来代表这段程序流。Java中通过继承Thread类来创建并启动多线程的步骤如下:
- 定义Thread类的子类,并重写该类的run()方法,该run()方法的方法体就代表了线程需要完成的任务,因此把run()方法称为线程执行体。
- 创建Thread子类的实例,即创建了线程对象
- 调用线程对象的start()方法来启动该线程
代码运行如下:
package Demo11;
public class Demo {
public static void main(String[] args) {
System.out.println("这里是main线程");
MyThread mt = new MyThread("小强");
mt.start();//开启了一个新的线程
for (int i = 0; i < 20; i++) {
System.out.println("旺财"+i);
}
}
}
public class MyThread extends Thread {
public MyThread(String name) {
super(name);
}
@Override
public void run() {
for (int i = 0; i < 20; i++) {
System.out.println(getName()+i);
//getName()方法,来自父亲
}
}
}
运行结果如图:
流程图如下:
程序启动运行main时候,java虚拟机启动一个进程,主线程main在main()调用时候被创建。随着调用mt的对象的 start方法,另外一个新的线程也启动了,这样,整个应用就在多线程下运行。
通过这张图我们可以很清晰的看到多线程的执行流程,那么为什么可以完成并发执行呢?我们再来讲一讲原理。
多线程执行时,到底在内存中是如何运行的呢?以上个程序为例,进行图解说明:
多线程执行时,在栈内存中,其实每一个执行线程都有一片自己所属的栈内存空间。进行方法的压栈和弹栈。
2 Thread类
构造方法:
public Thread()
:分配一个新的线程对象。
public Thread(String name)
:分配一个指定名字的新的线程对象。
public Thread(Runnable target)
:分配一个带有指定目标新的线程对象。
public Thread(Runnable target, String name)
:分配一个带有指定目标新的线程对象并指定名字。
常用方法:
public String getName( )
:获取当前线程名称。
public void start( )
:导致此线程开始执行;java虚拟机调用此线程的run方法。
public void run( )
:此线程要执行的任务在此处定义代码。
public static void sleep(long millis)
:使当前正在执行的线程以指定的毫秒数暂停(暂时停止执行)。
public static Thread currentThread( )
:返回当前正在执行的线程对象的引用。
代码运行如下:
public class Demo01Thread {
public static void main(String[] args) throws InterruptedException {
//创建Thread类的子类对象
MyThread mt1 = new MyThread();
//调用start方法,开启新线程,执行run方法
mt1.start();
new MyThread().start();
new MyThread().start();
//链式编程
System.out.println(Thread.currentThread().getName());
System.out.println("=================================");
MyThread.sleep(1000);
new MyThread("小强").start();
MyThread mt2 = new MyThread();
mt2.setName("旺财");
mt2.start();
}
}
运行结果如图:
3 Runnable接口
采用java.lang.Runnable
是一种常见的创建线程的方式,只需要重写run方法即可。
步骤如下:
- 定义Runnable接口的实现类,并重写该接口的run()方法,该run()方法的方法体同样是该线程的线程执行体。
- 创建Runnable实现类的实例,并以此实例作为Thread的target来吃创建Thread对象,该Thread对象才是真正的线程对象。
- 调用线程对象的start()方法来启动线程。
代码如下:
package Demo04;
/*
创建多线程程序的第二种方式:实现Runnable接口
java.lang.Runnable
Runnable 接口应该由那些打算通过某一线程执行其实例的类来实现。类必须定义一个称为 run 的无参数方法。
java.lang.Thread类的构造方法
Thread(Runnable target) 分配新的 Thread 对象。
Thread(Runnable target, String name) 分配新的 Thread 对象。
实现步骤:
1.创建一个Runnable接口的实现类
2.在实现类中重写Runnable接口的run方法,设置线程任务
3.创建一个Runnable接口的实现类对象
4.创建Thread类对象,构造方法中传递Runnable接口的实现类对象
5.调用Thread类中的start方法,开启新的线程执行run方法
实现Runnable接口创建多线程程序的好处:
1.避免了单继承的局限性
一个类只能继承一个类(一个人只能有一个亲爹),类继承了Thread类就不能继承其他的类
实现了Runnable接口,还可以继承其他的类,实现其他的接口
2.增强了程序的扩展性,降低了程序的耦合性(解耦)
实现Runnable接口的方式,把设置线程任务和开启新线程进行了分离(解耦)
实现类中,重写了run方法:用来设置线程任务
创建Thread类对象,调用start方法:用来开启新线程
*/
public class Demo01Runnable {
public static void main(String[] args) {
//3.创建一个Runnable接口的实现类对象
Runnable run = new RunnableImpl();
//4.创建Thread类对象,构造方法中传递Runnable接口的实现类对象
Thread t = new Thread(run);
//Thread t = new Thread(new RunnableImpl2());
//5.调用Thread类中的start方法,开启新的线程执行run方法
t.start();
System.out.println("====================");
for (int i = 0; i < 20; i++) {
System.out.println(Thread.currentThread().getName()+"-->"+i);
}
// System.out.println("====================");
Runnable run2 = new RunnableImpl2();
Thread t2 = new Thread(run2);
t2.start();
}
}
//1.创建一个Runnable接口的实现类
public class RunnableImpl implements Runnable{
//2.在实现类中重写Runnable接口的run方法,设置线程任务
@Override
public void run() {
for (int i = 0; i < 20; i++) {
System.out.println(Thread.currentThread().getName()+"-->"+i);
}
}
}
//1.创建一个Runnable接口的实现类
public class RunnableImpl2 implements Runnable {
//2.在实现类中重写Runnable接口的run方法,设置线程任务
@Override
public void run() {
for (int i = 0; i < 20; i++) {
System.out.println("HelloWorld"+i);
}
}
}
运行结果如图:
通过实现Runnable接口,使得该类有了多线程的特征。run()方法是多线程程序的一个执行目标。所有的多线程代码都在run方法里面。Thread类实际上也是实现了Runnable接口的类。
在启动的多线程的时候,需要先通过Thread类的构造方法Thread(Runnable target)构造对象,然后调用Thread对象的start()方法来运行多线程代码。
实际上所有的多线程代码都是通过运行Thread的start()方法来运行的,因此,不管是继承Thread类还是实现Runnable接口来实现多线程,最终还是通过Thread的对象的API来控制线程的,熟悉Thread类的API是进行多线程编程的基础。
注意:Runnable对象仅仅作为Thread对象的target,Runnable实现类里的包含的run()方法仅作为线程执行体。而实际的线程对象依然是Thread实例,只是该Thread线程负责其target的run()方法。
3.1 Thread和Runnable的区别
如果一个类继承Thread,则不适合资源共享。但是如果实现了Runnable接口的话,则很容易实现资源共享。
实现Runnable接口比继承Thread类所具有的优势:
- 适合多个相同的程序代码的线程去共享同一个资源。
- 可以避免java中的单继承的局限性。
- 增加程序的健壮性,实现解耦操作,代码可以被多个线程共享,代码和线程独立。
- 线程池只能放入实现Runnable或Callable类线程,不能直接放入继承Thread的类。
注意:在java中,每次程序运行至少启动2个线程,一个是main线程,一个是垃圾收集线程。因为每当使用java命令执行一个类的时候,实际上都会启动一个JVM,每个JVM其实就是在操作系统中启动了额一个进程。
3.2 匿名内部类方式实现线程的创建
使用线程的匿名内部类方式,可以方便的实现每个线程执行不同的线程任务操作。
使用匿名内部类的方式实现Runnable接口,重新Runnable接口中的run方法:
代码如下:
package Demo05;
import Demo04.RunnableImpl;
/*
匿名内部类方式实现线程的创建
匿名:没有名字
内部类:写在其他类内部的类
匿名内部类作用:简化代码
把子类继承父类,重写父类的方法,创建子类对象合一步完成
把实现类实现类接口,重写接口中的方法,创建实现类对象合成一步完成
匿名内部类的最终产物:子类/实现类对象,而这个类没有名字
格式:
new 父类/接口(){
重复父类/接口中的方法
};
*/
public class Demo05InnerClassThread {
public static void main(String[] args) {
//线程的父类是Thread
// new MyThread().start();
new Thread(){
@Override
public void run(){
for (int i = 0; i < 20; i++) {
System.out.println(Thread.currentThread().getName()+"-->java"+i);
}
}
}.start();
//线程的接口Runnable
//Runnable r = new RunnableImpl();//多态
Runnable r = new RunnableImpl() {//多态
//重写run方法,设置线程方法
@Override
public void run() {
for (int i = 0; i < 20; i++) {
System.out.println(Thread.currentThread().getName()+"-->javase"+i);
}
}
};
new Thread(r).start();
//简化接口的方式
new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 20; i++) {
System.out.println(Thread.currentThread().getName()+"-->R"+i);
}
}
}).start();
}
}
运行结果如图:
4 线程安全
如果有多个线程在同时运行,而这些线程可能会同时运行这段代码,程序每次运行结果和单线程运行的结果是一样的,而且其他的变量值也和预期的是一样的 ,就是说线程是安全的。
通过案例演示线程的安全问题如下:
模拟电影院的卖票过程,本次电影的座位共100个,实现多个窗口同时卖票,需要窗口,采用线程对象来模拟;需要票,Runnable接口子类来模拟。
代码运行如下:
/*
模拟卖票案例
创建3个线程,同时开启,对共享的票进行出售
*/
public class Demo01Ticket {
public static void main(String[] args) {
//创建Runnable接口的实现类对象
RunnableImpl run = new RunnableImpl();
//创建Thread类对象,构造方法中传递Runnable接口的实现类对象
Thread t0 = new Thread(run);
Thread t1 = new Thread(run);
Thread t2 = new Thread(run);
//调用start方法开启多线程
t0.start();
t1.start();
t2.start();
}
}
public class RunnableImpl implements Runnable{
//定义一个多个线程共享的票源
private int ticket = 100;
//设置线程任务:卖票
@Override
public void run() {
//使用死循环,让卖票操作重复执行
while(true){
//先判断票是否存在
if(ticket>0){
//提高安全问题出现的概率,让程序睡眠
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
//票存在,卖票 ticket--
System.out.println(Thread.currentThread().getName()+"-->正在卖第"+ticket+"张票");
ticket--;
}
}
}
}
部分结果如图:
发现程序出现了两个问题:
- 相同的票数被卖了多次。
- 售出了不存在的票,比如0和-1。
注意:
线程安全问题都是由全局变量及静态变量引起的,若每个线程中对全局变量、静态变量只有读操作,而无写操作,一般来说,这个全局变量是线程安全的;若有多个线程同时执行写操作,一般都需要考虑线程同步,否则的话就可能影响线程安全。
5 线程同步
当多个线程访问同一资源时,且多个线程对资源有写的操作,就容易出现线程安全问题。要解决上述过程并发访问一个资源的安全性问题:也就是解决重复票与不存在票问题,java中提供了同步机制(synchronized)来解决。
有三种方式完成同步操作:
- 同步代码块
- 同步方法
- 锁机制
同步原理如图:
5.1 同步代码块
synchronized
关键字可以用于方法中的某个区块中,表示只对这个区块的资源实现互斥访问。
格式:
synchronized(同步锁){
需要同步操作的代码
}
同步锁:
对象的同步锁只是一个概念,可以想象为在对象上标记了一个锁。
- 锁对象可以是任意类型。
- 多个线程对象,要使用同一把锁。
- 在任何时候,最多允许一个线程拥有同步锁,谁拿到锁进入代码块,其他的线程只能在外等着(BLOCKED)。
代码运行如下:
package Demo07;
import Demo07.RunnableImpl;
public class Demo01Ticket {
public static void main(String[] args) {
//创建Runnable接口的实现类对象
Runnable run = new RunnableImpl();
//创建Thread类对象,构造方法中传递Runnable接口的实现类对象
Thread t0 = new Thread(run);
Thread t1 = new Thread(run);
Thread t2 = new Thread(run);
//调用start方法开启多线程
t0.start();
t1.start();
t2.start();
}
}
public class RunnableImpl implements Runnable{
//定义一个多个线程共享的票源
private int ticket = 100;
//创建一个锁对象
Object obj = new Object();
//设置线程任务:买票
@Override
public void run(){
//使用死循环,让卖票操作重复执行
boolean flag = true;
while (flag){
//同步代码块
synchronized(obj){
//先判断票是否存在
if(ticket>0){
try{
Thread.sleep(100);
}catch(InterruptedException e){
e.printStackTrace();
}
//票存在,卖票 ticket--
System.out.println(Thread.currentThread().getName()+"-->正在卖第"+ticket+"票");
ticket--;
}
else{
flag = false;
}
}
}
}
}
运行结果如图:
5.2 同步方法
使用synchronized
修饰的方法,就叫做同步方法,保证A线程执行该方法的时候,其他线程只能在方法外等着。
格式:
public synchronized void main(){
//可能会产生线程安全问题的代码
}
代码运行如下:
/*
模拟卖票案例
创建3个线程,同时开启,对共享的票进行出售
*/
public class Demo01Ticket {
public static void main(String[] args) {
//创建Runnable接口的实现类对象
RunnableImpl run = new RunnableImpl();
System.out.println("run:"+run);
//创建Thread类对象,构造方法中传递Runnable接口的实现类对象
Thread t0 = new Thread(run);
Thread t1 = new Thread(run);
Thread t2 = new Thread(run);
//调用start方法开启多线程
t0.start();
t1.start();
t2.start();
}
}
/*
卖票案例出现了线程安全问题
卖出了不存在的票和重复的票
解决线程安全问题的二种方案:使用同步方法
使用步骤:
1.把访问了共享数据的代码抽取出来,放到一个方法中
2.在方法上添加synchronized修饰符
格式:定义方法的格式
修饰符 synchronized 返回值类型 方法名(参数列表){
可能会出现线程安全问题的代码(访问了共享数据的代码)
}
*/
public class RunnableImpl implements Runnable{
//定义一个多线程共享的票源
private int ticket = 100;
private boolean flag = true;
//设置买票线程任务:卖票
@Override
public void run() {
System.out.println("this:"+this);
//使用循环,让卖票操作重复执行
while(flag){
payTicket();
System.out.println(ticket);
}
}
private synchronized void payTicket() {
//先判断票是否存在
if(ticket > 0){
//提高安全问题出现的概率,让程序睡眠
try{
Thread.sleep(100);
}catch (InterruptedException e){
e.printStackTrace();
}
//票存在,卖票,ticket--
System.out.println(Thread.currentThread().getName()+"正在卖第"+ticket+"张票");
ticket--;
}
else{
flag = false;
System.out.println(ticket);
}
}
}
运行部分结果如图:
同步锁是谁?
对于非static方法,同步锁就是this。
对于stctic方法,我们使用当前方法所在类的字节码对象(类名.class)。
代码如下:
public class RunnableImpl3 implements Runnable {
//定义一个多线程共享的票源
private int ticket = 100;
private boolean flag = true;
//设置买票线程任务:卖票
@Override
public void run() {
System.out.println("this:"+this);
//使用循环,让卖票操作重复执行
while(flag){
payTicket();
System.out.println(ticket);
}
}
/*
定义一个同步方法
同步方法也会把方法内部的代码锁住
只让一个线程执行
同步方法的锁对象是谁?
就是实现类对象 new RunnableImpl()
也是就是this
*/
private void payTicket() {
synchronized (this){
//先判断票是否存在
if(ticket > 0){
//提高安全问题出现的概率,让程序睡眠
try{
Thread.sleep(10);
}catch (InterruptedException e){
e.printStackTrace();
}
//票存在,卖票,ticket--
System.out.println(Thread.currentThread().getName()+"正在卖第"+ticket+"张票");
ticket--;
}
else{
flag = false;
System.out.println(ticket);
}
}
}
}
运行结果如图:
静态方法运行代码如下:
public class RunnableImpl2 implements Runnable{
//定义一个多线程共享的票源
private static int ticket = 100;
private static boolean flag = true;
//设置买票线程任务:卖票
@Override
public void run() {
System.out.println("this:"+this);
//使用循环,让卖票操作重复执行
while(flag){
payTicketStatic();
System.out.println(ticket);
}
}
/*
静态的同步方法
锁对象是谁?
不能是this
this是创建对象之后产生的,静态方法优先于对象
静态方法的锁对象是本类的class属性-->class文件对象(反射)
*/
private static void payTicketStatic() {
synchronized (RunnableImpl.class){
//先判断票是否存在
if(ticket > 0){
//提高安全问题出现的概率,让程序睡眠
try{
Thread.sleep(10);
}catch (InterruptedException e){
e.printStackTrace();
}
//票存在,卖票,ticket--
System.out.println(Thread.currentThread().getName()+"正在卖第"+ticket+"张票");
ticket--;
}
else{
flag = false;
System.out.println(ticket);
}
}
}
}
运行结果如图:
5.2 Lock锁
java.util.concurrent.locks.Lock
机制提供了比synchronized代码块和synchronized方法更广泛的锁定操作,同步代码块/同步方法具有的功能Lock都有,除此之外更强大,更体现面向对象。
Lock锁也称同步锁,加锁与释放锁方法了,如下:
public void lock( ):
加同步锁。
public void unlock( ):
释放同步锁。
代码运行如下:
package Demo09;
/*
模拟卖票案例
创建3个线程,同时开启,对共享的票进行出售
*/
public class Demo01Ticket {
public static void main(String[] args) {
//创建Runnable接口的实现类对象
RunnableImpl run = new RunnableImpl();
//创建Thread类对象,构造方法中传递Runnable接口的实现类对象
Thread t0 = new Thread(run);
Thread t1 = new Thread(run);
Thread t2 = new Thread(run);
//调用start方法开启多线程
t0.start();
t1.start();
t2.start();
}
}
/*
卖票案例出现了线程安全问题
卖出了不存在的票和重复的票
解决线程安全问题的三种方案:使用Lock锁
java.util.concurrent.locks.Lock接口
Lock 实现提供了比使用 synchronized 方法和语句可获得的更广泛的锁定操作。
Lock接口中的方法:
void lock()获取锁。
void unlock() 释放锁。
java.util.concurrent.locks.ReentrantLock implements Lock接口
使用步骤:
1.在成员位置创建一个ReentrantLock对象
2.在可能会出现安全问题的代码前调用Lock接口中的方法lock获取锁
3.在可能会出现安全问题的代码后调用Lock接口中的方法unlock释放锁
*/
public class RunnableImpl implements Runnable{
//定义一个多线程共享的票源
private int ticket = 100;
private boolean flag = true;
//1.在成员位置创建一个ReentrantLock对象
Lock l = new ReentrantLock();
//设置线程任务:卖票
@Override
public void run() {
//使用循环,让卖票操作重复执行
while(flag){
//2.在可能会出现安全问题的代码前调用Lock接口中的方法lock获取锁
l.lock();
//先判断票是否存在
if(ticket > 0){
//提高安全问题出现的概率,让程序睡眠
try{
Thread.sleep(100);
//票存在,卖票,ticket--
System.out.println(Thread.currentThread().getName()+"-->正在卖第"+ticket--+"张票");
}catch (InterruptedException e){
e.printStackTrace();
}
finally{
//3.在可能会出现安全问题的代码后调用Lock接口中的方法unlock释放锁
l.unlock();//无论程序是否异常,都会把锁释放
}
}
else{
flag = false;
}
}
}
运行结果如图:
6 线程状态
6.1 等待唤醒机制
多个线程并发执行时,在默认情况下CPU是随机切换线程的,当需要多个线程来共同完成一件任务,并且希望它们有规律的执行,那么多线程之间需要一些协调通信,一次来达到多线程共同操作一份数据。
多个线程在处理同一资源,并且任务不同时,需要线程通信来帮助解决线程之间对同一个变量的使用或操作,就是多个线程在操作同一份数据时,避免对同一共享变量的争夺。也就是我们需要通过一定的手段使各个线程能有效的利用资源,而这种手段就是——等待唤醒机制。
等待唤醒机制就是用于解决线程间通信的问题的,使用的3个方法的含义如下:
- wait:线程不再活动,不再参与调度,进入wait set中,因此不会浪费CPU资源,也不会竞争锁,这时的线程状态即是WAITING。它还要等着别的线程执行一个特别的动作,也即是“通知(notify)”在这个对象上等待的线程从wait set中释放出来,重新进入调度队列(ready queue)中。
- notify:则选取所通知对象的wait set中的一个线程释放,例如。餐馆有空位置后,等待就餐最久的顾客最先入座。
- notifyAll:则释放所通知对象的wait set上的全部线程。
注意:
(1)哪怕只通知了一个等待的线程,被通知的线程也不能立即恢复执行,因为它当初中断的地方是在同步块内,而此刻它已经不持有锁,所有它需要再次尝试去获取锁(很可能面临其他线程的竞争),成功后才能在当初调用wait方法之后的地方恢复执行。
(2) wait方法与notify方法必须由同一个锁对象调用。因为:对应的锁对象可以通过notify唤醒使用同一个锁对象调用的wait方法后的线程。
(3)wait方法与notify方法是属于Object类的方法的,因为:锁对象可以是任意对象,而任意对象的所属类都是继承了Object类的。
(4)wait与notify方法必须要在同步代码块或者是同步函数中使用。因为:必须要通过锁对象调用这2个方法。
6.2 生产者与消费者问题
包子铺线程生产包子,吃货线程消费包子。当包子没有时(包子状态为false),吃货线程等待,包子铺线程生产包子(即包子状态为true),并通知吃货线程(解除吃货的等待状态),因为已经有包子了,那么包子铺线程进入等待状态。接下来,吃货线程能否进一步执行则取决于锁的获取情况。如果吃货获取到锁,那么就执行吃包子动作,包子吃完(包子状态为false),并通知包子铺线程(解除包子铺的等待状态),吃货线程进入等待。包子铺线程能否进一步执行则取决于锁的获取情况。
代码运行如下:
package Demo01;
public class WaitAndNotify {
public static void main(String[] args) {
//等待唤醒案例
BaoZi bz = new BaoZi();
ChiHuo ch = new ChiHuo(bz);
BaoZiPu bzp = new BaoZiPu(bz);
ch.start();
bzp.start();
}
}
public class BaoZi {
String pier;
String xianer;
boolean flag = false; //包子资源是否存在
}
public class BaoZiPu extends Thread{
private BaoZi bz;
public BaoZiPu(BaoZi bz) {
this.bz = bz;
}
@Override
public void run() {
System.out.println("包子铺线程");
int count = 0;
//造包子
while(true){
//同步
synchronized (bz){
if(bz.flag == true){//包子资源存在
try{
bz.wait();
}catch (InterruptedException e){
e.printStackTrace();
}
}
//没有包子,开始造包子
System.out.println("包子铺开始做包子");
if(count%2 == 0 ){
//冰皮 五仁
bz.pier = "冰皮";
bz.xianer = "五仁";
}else{
//薄皮 牛肉大葱
bz.pier = "薄皮";
bz.xianer = "牛肉大葱";
}
count++;
bz.flag = true;
System.out.println("包子造好了:"+bz.pier + bz.xianer);
System.out.println("吃货来吃吧");
System.out.println("========================");
//唤醒等待线程(吃货)
bz.notify();
}
}
}
}
public class ChiHuo extends Thread{
private BaoZi bz;
public ChiHuo(BaoZi bz){
this.bz = bz;
}
@Override
public void run() {
System.out.println("吃货线程");
while(true){
synchronized (bz){
if(bz.flag == false){//没包子
try{
bz.wait();
}catch (InterruptedException e){
e.printStackTrace();
}
}
System.out.println("吃货正在吃"+bz.pier + bz.xianer +"包子");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("-----------------------------------------");
bz.flag = false;
bz.notify();
}
}
}
}
运行结果如图:
7 线程池
线程池:其实就是一个容纳多个线程的容器,其中的线程可以反复使用,省去了频繁创建线程对象的操作,无需反复创建线程而消耗过多资源。
合理利用线程池能够带来三个好处:
- 降低资源消耗。减少了创建和销毁线程的次数,每个工作线程都可以被重复利用,可执行多个任务。
- 提高响应速度。当任务到达时,任务可以不需要的等到线程创建就能立即执行。
- 提高线程的可管理性。可以根据系统的承受能力,调整线程池中工作线线程的数目,防止因为消耗过多的内存,而把服务器累趴下(每个线程需要大约1MB内存,线程开的越多,消耗的内存也就越大,最后死机)。
7.1 线程池的使用
Java里面线程池的顶级接口是java.util.concurrent.Executor
,但是严格意义上讲Executor
并不是一个线程池,而只是一个执行线程的工具。真正的线程池接口是java.util.concurrent.ExecutorService
。
要配置一个线程池是比较复杂的,尤其是对于线程池的原理不是很清楚的情况下,很有可能配置的线程池不是较优的,因此在java.util.concurrent.Executors
线程工厂类里面提供了一些静态工厂,生成一些常用的线程池。官方建议使用Executors工程类来创建线程池对象。
Executors类中有个创建线程池的方法如下:
public static ExecutorService newFixedThreadPool(int nThreads)
:返回线程池对象。(创建的是有界线程池,也就是池中的线程个数可以指定最大数量)
获取到了一个线程池ExecutorService 对象,那么怎么使用呢,在这里定义了一个使用线程池对象的方法如下:
-
public Future<?> submit(Runnable task)
:获取线程池中的某一个线程对象,并执行Future接口:用来记录线程任务执行完毕后产生的结果。线程池创建与使用。
使用线程池中线程对象的步骤:
- 创建线程池对象。
- 创建Runnable接口子类对象。(task)
- 提交Runnable接口子类对象。(take task)
- 关闭线程池(一般不做)。
代码运行如下:
/*
线程池:JDK1.5之后提供的
java.util.concurrent.Executors:线程池的工厂类,用来生成线程池
Executors类中的静态方法:
static ExecutorService newFixedThreadPool(int nThreads) 创建一个可重用固定线程数的线程池
参数:
int nThreads:创建线程池中包含的线程数量
返回值:
ExecutorService接口,返回的是ExecutorService接口的实现类对象,我们可以使用ExecutorService接口接收(面向接口编程)
java.util.concurrent.ExecutorService:线程池接口
用来从线程池中获取线程,调用start方法,执行线程任务
submit(Runnable task) 提交一个 Runnable 任务用于执行
关闭/销毁线程池的方法
void shutdown()
线程池的使用步骤:
1.使用线程池的工厂类Executors里边提供的静态方法newFixedThreadPool生产一个指定线程数量的线程池
2.创建一个类,实现Runnable接口,重写run方法,设置线程任务
3.调用ExecutorService中的方法submit,传递线程任务(实现类),开启线程,执行run方法
4.调用ExecutorService中的方法shutdown销毁线程池(不建议执行)
*/
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class Demo01ThreadPool {
public static void main(String[] args) {
//1.使用线程池的工厂类Executors里边提供的静态方法newFixedThreadPool生产一个指定线程数量的线程池
ExecutorService es = Executors.newFixedThreadPool(2);
//3.调用ExecutorService中的方法submit,传递线程任务(实现类),开启线程,执行run方法
es.submit(new RunnabeImpl());//pool-1-thread-1创建了一个新的线程执行
//线程池会一直开启,使用完了线程,会自动把线程归还给线程池,线程可以继续使用
es.submit(new RunnabeImpl());//pool-1-thread-1创建了一个新的线程执行
es.submit(new RunnabeImpl());//pool-1-thread-2创建了一个新的线程执行
//4.调用ExecutorService中的方法shutdown销毁线程池(不建议执行)
es.shutdown();
//es.submit(new RunnableImpl());//抛异常,线程池都没有了,就不能获取线程了
}
}
public class RunnabeImpl implements Runnable {
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"-->创建了一个新线程执行");
}
}
运行结果如下: