并发与并行
程序
一段静态的代码。
进程
是指内存中运行的应用程序。
线程
是进程中的一个执行单元。
主线程——执行主(main)方法的线程
单线程程序—————java程序中只有一个线程。
执行从main方法开始,从上到下依此执行。
创建多线程程序的第一种实现方式
创建Thread类的子类
java.lang.thread类是描述线程的类,我们想要实现多线程程序,就必须继承Thread类。
实现步骤
- 创建一个Thread类的子类。
- 在Thread类的子类中重写Thread类的run方法,设置线程任务(开启线程要做什么?)
- 创建Thread类的子类对象。
- 调用Thread类中的start方法,开启新的线程,执行run方法。
void start()使该线程开始执行;Java虚拟机调用现成的run方法。
结果是两个线程并发地运行;当前线程(main线程)和另外一个线程(创建的新线程,并执行其run方法)。
多次启动一个线程是非法的。特别是当线程已经结束执行后,不能再重新启动。
Java程序属于抢占式调度,哪个线程的优先级高,哪个线程优先执行,同一个优先级,随机选择一个执行。
多线程原理————随机性打印结果
多线程原理————多线程内存图解
Thread类的常用方法
获取线程的名称
- 使用Thread类中的方法getName()。
String getName()返回该线程的名称。 - 可以获取到当前正在执行的线程,使用线程中的方法getName()获取线程的名称。
static Thread currentThread()
返回对当前正在执行的线程对象的引用。
设置线程的名称
1.使用Thread类中的方法setName(名字)。
void setName(String name )改变线程名称,使之与参数name相同。
2.创建一个带参数的构造方法,参数传递线程的名称,调用父类的带参构造方法,把线程名称传递给父类让父类(Thread)给子线程起一个名字。
Thread (String name)分配新的Thread对象。
sleep
public static void sleep(long millis)——使当前正在执行的线程以指定的毫秒数暂停(暂时停止执行)。
创建多线程程序的第二种实现方式
实现Runnable接口
java.lang.Runnable
Runnable接口应该由那些打算通过某一线程执行其实例类来实现。类必须定义一个称为run的无参方法。
java.lang.thread类的构造方法
- Thread(Runnable target)分配新的Thread对象。
- Thread(Runnable target)分配新的Thread对象。
实现步骤
1.创建一个Runnable接口的实现类。
2.在实现类中重写Runnable接口的run方法,设置线程任务。
3.创建一个Runnable接口的实现类对象。
4.创建Thread类对象,构造方法中传递Runnable接口的实现类对象。
5.调用Thread类中的start方法,开启新的线程执行run方法。
Thread和Runnable的区别
实现Runnable接口创建多线程程序的好处
- 避免了单继承的局限性
一个类只能继承一个类(一个人只能有一个亲爹),类继承了Thread类就不能继承其他的类。
实现了Runnable接口,还可以继承其他的类,实现其他的接口。 - 增强了程序扩展性,降低了程序的耦合性(解耦)。
实现Runnable接口的方式,把设置线程任务和开启新线程进行了分离(解耦)。
实现类中,重写了run方法————用来设置线程任务。
创建Thread类对象,调用start方法,用来开启新线程。
匿名内部类方式实现线程的创建
匿名————没有名字
内部类———写在其他内部的类
匿名内部类作用————————简化代码
-
把子类继承父类,重写父类的方法,创建子类对象。
-
把实现类实现类接口,重写接口中的方法,创建实现类对象合成异步完成。
匿名内部类最终产物————子类/实现类对象,而这个类没有名字。
格式new 父类/接口(){
重复父类/接口中的方法
};
线程安全问题
线程安全问题代码实现
/**
* 实现买票案例
*/
public class RunableImpl 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--;
}
}
}
}
public class Demo01Ticket {
public static void main(String[] args) {
//创建Runnable接口的实现类对象
RunableImpl run = new RunableImpl();
//创建Thread类对象,构造方法中传递Runnable接口的实现类对象
Thread t0 = new Thread(run);
Thread t1 = new Thread(run);
Thread t2 = new Thread(run);
//调用start方法开启多线程
t0.start();
t1.start();
t2.start();
}
}
线程安全问题产生的原理
解决线程安全问题————同步代码块
买票案例出现了线程安全问题
卖出了不存在的票和重复的票。
解决线程安全问题的一种方案———————使用同步代码块
格式
synchronized(锁对象){
可能会出现线程安全问题的代码(访问了共享数据的代码)
}
注意
- 通过代码中的锁对象,可以使用任意的对象
- 但是必须保证多个线程使用的所对象是同一个。
- 锁对象作用————把同步代码块锁住,只让一个线程在同步代码中执行。
同步技术的原理
解决线程安全问题————同步方法
使用步骤
- 把访问了共享数据的代码抽取出来,放到一个方法中。
- 在方法上添加synchronized 修饰符。
格式
修饰符 synchronized 返回值类型 方法名(参数列表){
可能会出现线程安全问题的代码(访问了共享数据的代码)
}
定义一个同步方法
同步方法也会把方法内部的代码锁住
只让一个线程执行。
同步方法的锁对象是谁?
就是实现类对象 new RunnableTmpl()
也就是this。
静态的同步方法
锁对象是谁?
不能是this
this是创建对象之后随机产生的,静态方法优先于对象。
解决线程安全问题————Lock锁
java.util.concurrent.locks.Lock接口
Lock实现提供了比使用synchronized 方法和语句可获得的更广泛的锁操作。
Lock接口中的方法
- void lock()获取锁。
- void unlock()释放锁。
java.util.concurrent.locks.ReentranLock implements Lock接口
使用步骤
- 在成员位置创建一个ReentranLock 对象。
- 在可能会出现安全问题的代码前调用Lock接口中的方法lock获取锁。
- 在可能会出现安全问题的代码前调用Lock接口中的方法unlock释放锁。
线程状态
等待唤醒案例
/**
* 等待唤醒案例——————线程之间的通信
* 创建一个顾客线程(消费者)————告知老板要的包子的种类和数量,调用wait方法,放弃CPU的执行,进入到WAITING状态(无限等待)。
* 创建一个老板线程(生产者)————花了5秒,做好包子之后,调用notify方法,唤醒顾客吃包子。
* 注意
* 顾客和老板线程必须使用同步代码块包裹起来,保证等待和唤醒只能有一个在执行。
* 同步使用的锁对象必须保证唯一。
* 只有锁对象才能调用wait和notify方法。
* Object类中的方法
* void wait()
* 在其他线程调用此对象的notify方法或者notifyAll方法前,导致当前线程等待。
* void notify()
* 唤醒在此对象监视器上等待的单线程。
* 会继续执行wait方法之后的代码。
*/
public class Demo01WaitAndNotify {
public static void main(String[] args) {
//创建对象,保证唯一
Object obj = new Object();
//创建一个顾客线程(消费者)
new Thread() {
@Override
public void run() {
//一直等着买包子
while (true){
//保证等待和唤醒的线程只能有一个执行,需要使用同步技术
synchronized (obj) {
System.out.println("告知老板要的包子种类和数量");
//调用wait方法,放弃CPU的执行,进入到WAITING状态(无限等待)
try {
obj.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
//唤醒之后执行的代码
System.out.println("包子已经做好,开吃");
System.out.println("=======================");
}
}
}
}.start();
//创建一个老板线程(生产者)
new Thread(){
@Override
public void run() {
//一直做包子
while (true){
//花了5秒做包子
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//保证等待和唤醒的线程只能有一个执行,需要使用同步技术
synchronized (obj) {
//做好包子之后,调用notify方法,唤醒顾客吃包子。
System.out.println("老板花了5秒做包子,唤醒顾客吃包子");
obj.notify();
}
}
}
}.start();
}
}
进入到TimeWaiting(计时等待)有两种方式
- 使用sleep(long m)方法,在毫秒值结束之后,线程睡醒进入到Runnable/Blocket状态。
- 使用wait(long m)方法,wait方法如果在毫秒值结束之后,还没有被notifiy唤醒,就会自动醒来,线程睡醒进入到Runnable/Blocket状态。
唤醒的方法
- void notify()唤醒在此对象监视器上等待的单个线程。
- void notifyAll()唤醒在此对象监视器上等待的单个所有线程。
等待唤醒机制需求分析
等待唤醒机制代码实现——包子类&包
public class DemoTest {
public static void main(String[] args) {
//创建包子对象
Baozi bz=new Baozi();
//创建包子铺线程,开启,生产包子;
new BaoZiPu(bz).start();
//创建吃货线程,开启,吃包子
new CiHuo(bz).start();
}
}
/*
* 生产者(包子铺)类————是一个线程类,可以继承Thread
* 设置线程任务(run)———生产包子
* 对包子的状态进行判断
* true————————————————有包子
* 包子铺调用wait方法进入等待状态
* false———————————————没有包子
* 包子铺生产包子
* 增加一些趣味性————————交替生产两种包子
* 有两种状态(i%2==0)
* 包子铺生产好了包子
* 修改包子的状态为true有
* 唤醒吃货线程,让吃货线程吃包子
* */
/*注意
* 包子铺线程和包子线程关系-->通信(互斥)
* 必须同时同步技术保证两个线程只能有一个在执行
* 锁对象必须保证唯一,可以使用包子对象作为锁对象
* 包子铺类和吃货的类就需要把包子对象作为参数传递进来
* 1.需要在成员变量位置创建一个包子变量
* 2.使用带参数构造方法,为这个包子变量赋值*/
public class BaoZiPu extends Thread {
// 1.需要在成员变量位置创建一个包子变量
private Baozi bz;
// 2.使用带参数构造方法,为这个包子变量赋值
public BaoZiPu(Baozi bz) {
this.bz = bz;
}
@Override
public void run() {
//定义一个变量
int count = 0;
//让包子铺一直生产包子
while (true) {
//必须同时同步技术保证两个线程只能有一个在执行
synchronized (bz) {
//对包子的状态进行判断
if (bz.flag == true) {
// 包子铺调用wait方法进入等待状态
try {
bz.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//被唤醒之后执行,包子铺生产包子
//增加一些趣味性————————交替生产两种包子
if (count % 2 == 0) {
//生产薄皮三鲜馅包子
bz.pi = "薄皮";
bz.xain = "三鲜馅";
} else {
//生产冰皮 牛肉大葱馅
bz.pi = "冰皮";
bz.xain = "牛肉大葱馅";
}
count++;
System.out.println("包子铺正在生产:" + bz.pi + bz.xain + "包子");
//生产包子需要3秒钟
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//包子铺生产好了包子
//修改包子的状态为true有
bz.flag = true;
//唤醒吃货线程,让吃货线程吃包子
bz.notify();
System.out.println("包子铺已经生产好了:" + bz.pi + bz.xain + "包子,吃货可以开始吃了");
}
}
}
}
/*
* 消费着(吃货)类——————————是一个线程类,可以继承Thread
* 设置线程任务(run)———————吃包子
* 对包子状态进行判断
* false———————————————没有包子
* 吃货调用wait方法进入等待状态
* true————————————————有包子
* 吃货吃包子
* 吃货吃完包子
* 吃货唤醒包子铺线程,生产包子
* */
public class CiHuo extends Thread{
// 1.需要在成员变量位置创建一个包子变量
private Baozi bz;
// 2.使用带参数构造方法,为这个包子变量赋值
public CiHuo(Baozi bz) {
this.bz = bz;
}
//设置线程任务(run)———————吃包子
@Override
public void run() {
//使用死循环,让吃货一直吃包子
while (true){
//必须同时同步技术保证两个线程只能有一个在执行
synchronized (bz){
//对包子的状态进行判断
if (bz.flag == false) {
// 吃货调用wait方法进入等待状态
try {
bz.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//被唤醒之后执行,吃货吃包子
System.out.println("吃货吃:" + bz.pi + bz.xain + "包子");
//吃货吃好了包子
//修改包子的状态为false没有
bz.flag = false;
//吃货唤醒包子铺线程,生产包子
bz.notify();
System.out.println("吃货已经把:" + bz.pi + bz.xain + "的包子吃光了,包子铺开始生产包子");
System.out.println("==============================");
}
}
}
}
/*
* 资源类————包子类
* 设置包子的属性
* 皮
* 馅
* 包子的状态————有true,没有false
**/
public class Baozi {
//皮
String pi;
//馅
String xain;
//包子的状态:有true,没有false,设置初始值为false没有包子
boolean flag = false;
}