并行和并发
1. 需求:边打英雄联盟和边听音乐
2. 问题:只能先后关系,并不能同时发生
-
多进程或者多线程来解决
3. 并行和并发:
-
并行:多件事情在同一时刻发生
-
并发:多件事情在同一时间段发生,同一时间段多个程序同时运行
4. 单个CPU:一个时间点只能执行一个程序,多个程序可以交替执行。
5. 线程调度:多个线程以某个顺序执行
进程与线程
1. 进程:内存中的应用程序,每个进程有一块独立的内存空间,一个应用程序可以同时启用多个进程,有独立内存空间,至少有一个线程
2. 线程:进程中的执行任务单元,一个进程里面可以拥有多个线程,栈空间独立,堆内存共享
3. 多线程的优势:因为堆内存是共享的,所以内存的开销是不是较少。
4. 多线程具体运行那个线程,取决于 CPU调度
5. java 程序中最少有几个线程:
-
主线程
-
GC垃圾回收线程
6. 线程的调度:JVM 采用抢占式的调度方式,没有采用分时概念,谁抢到谁执行。
7. 多线程的应用:
-
抢票
-
游戏
-
多线程下载
8. 宽带带宽:以位(bit)计算的,下载速度以字节(byte),1字节=8位
-
1024KB/s 代表 1M,下载速度,1024/8 128KB/s
多线程实现方式
1. 继承 Thread 类
- 重写 run 方法
public class MusicDemo extends Thread{
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println("听音乐:"+i);
}
}
}
- 启动线程,调用 start 方法
MusicDemo musicDemo = new MusicDemo();
musicDemo.start();
-
注意:不要去调用 run() 方法
2. 实现 Runnable 接口
- 实现Runnable 接口,实现 Run 方法
public class PlayGame implements Runnable {
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println("打游戏:" + i);
}
}
}
- 启动(先创建对象,再创建 Thread 对象通过构造器获得线程对象)
PlayGame playGame = new PlayGame();
Thread thread = new Thread(playGame);
thread.start();
3. 使用匿名内部类来创建线程(只适用于只使用一次的方式)
new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println("统计人头数:" + i);
}
}
}).start();
线程的调度
1. 线程控制操作:Thread.sleep(1000L);
2.线程合并(联合线程):
-
join方法(操作线程先执行完之后,等待线程才执行)
3. 守护线程:GC 使用
-
目的:为其它线程服务的—GC—
-
特点:主线程结束,守护线程就结束
-
创建线程:默认是前台线程
-
获取守护线程thread.setDaemon(true),必须再 start() 方法之前
4. 获取当前线程及其名称
-
Thread t = Thread.currentThread();
-
t.getName();
5. 线程设置优先级
- 注意:优先级高,只不过是获取执行机会更大(取决于CPU调度)
/**
* The minimum priority that a thread can have.
*/
public final static int MIN_PRIORITY = 1;
/**
* The default priority that is assigned to a thread.
*/
public final static int NORM_PRIORITY = 5;
/**
* The maximum priority that a thread can have.
*/
public final static int MAX_PRIORITY = 10;
6. 线程的让位:
-
yield 方法:当前线程对象去提示CPU调度器自己愿意让出CPU资源(但是调度器可以忽略你的请求)
-
sleep 和 yield 方法的区别
-
都能使当前处于运行状态的线程暂时放弃 cpu 把机会给其它线程
-
sleep 方法给其它线程运行机会,但是不考虑其它线程的优先级,yield 只会给相同优先级,或者更高优先级的线程运行机会
-
调用 sleep 方法之后,线程进入计时等待状态,yield 进入就绪状态
-
线程同步
1. 需求:猴子(3个 A B C)吃香蕉30个,使用多线程的方式实现
-
继承 Thread 类的方式
-
同一个编号的香蕉被多个猴子吃
-
public class MonkeyDemo extends Thread {
private int num = 30;//香蕉总数
@Override
public void run() {
for (int i = 0; i < 30; i++) {
if (num > 0) {
System.out.println(super.getName() + "吃了编号为:" + num-- + "的香蕉");
}
}
}
}
MonkeyDemo monkeyA = new MonkeyDemo();
monkeyA.setName("A");
MonkeyDemo monkeyB = new MonkeyDemo();
monkeyB.setName("B");
MonkeyDemo monkeyC = new MonkeyDemo();
monkeyC.setName("C");
monkeyA.start();
monkeyB.start();
monkeyC.start();}}
-
实现 Runnable 接口
-
是否可以共享同一个资源的原因,实现方式可以做到(当有网络延迟的时候,也不可以做到)
-
public class MonkeyRunnable implements Runnable{
private int num = 30;
@Override
public void run() {
for (int i = 0; i < 30; i++) {
if (num > 0) {
System.out.println(Thread.currentThread().getName() + "吃了编号为:" + num-- + "的香蕉");
}
}
}
}
MonkeyRunnable runnable = new MonkeyRunnable();
new Thread(runnable,"A").start();
new Thread(runnable,"B").start();
new Thread(runnable,"C").start();
2. 解决多个猴子不能同时吃到同一个香蕉的案例
-
同步代码块
-
语法
-
非静态
-
同步锁是谁?
-
非静态的来说,同步锁就是 this
-
静态的来说,类的字节对象(MonkeyRunnable.class)
-
-
synchronized(同步锁){
}
-
-
任何时候,只能运行一个线程拥有同步锁,谁拿到谁执行,其它的等待
-
不要使用同步锁去修饰 run 方法,修饰之后,某一个线程执行完了其它的才可以执行
-
为了保证每个线程都能够正常执行,原子操作,一般的,把当前并发访问的共同资源作为同步监听对象
-
- 同步方法
synchronized public void eat() {
//业务逻辑
}
- 锁机制(Lock):
Lock lock = new ReentrantLock();
//上锁
lock.lock();
if (num > 0) {
System.out.println(Thread.currentThread().getName() + "吃了编号为:" + num-- + "的香蕉");
}
//解锁
lock.unlock();
3. 同步代码块,同步方法,同步锁如何选用?
-
尽量减少锁的作用域(Synchronized)
-
建议使用锁机制(很好的去控制锁的作用范围,性能更高)
生产者与消费者模式
1. 线程通信:不同线程执行不同任务,如果这些任务存在关系,线程之间必须能够通信,协调完成工作
2. 需求:实现生产者与消费者模式
-
通过生产者与消费者操作共同资源
-
使用多个线程来做生产者(Producer)
-
使用多个线程来做消费者(Consumer)
3. 生产者以及消费者示意图:(体现面向对象设计原则:低耦合)
- 主板与集成显卡(高耦合)
//主板
public class Producer{
private Consumer cu;
}
//集成显卡
public class Consumer{
private Producer p;
}
- 板和内存条(方便升级)(低耦合)
//主板
public class Producer{
//资源
private ShareResource resource;
}
//内存
public class Consumer{
//资源
private ShareResource resource;
}
//内存卡槽
public class ShareResource{
}
实现生产者与消费者
public class Producer implements Runnable {
private ShareResource resource;
public Producer(ShareResource resource){
this.resource = resource;
}
@Override
public void run() {
for (int i = 0; i < 20; i++) {
if(i % 2 == 0){
resource.push("女士服装","s");
}else{
resource.push("男士服装","XXXL");
}
}
}
}
public class Consumer implements Runnable{
private ShareResource resource;
public Consumer(ShareResource resource){
this.resource = resource;
}
@Override
public void run() {
for (int i = 0; i < 20; i++) {
resource.pop();
}
}
}
public class ShareResource {
private String name;
private String size;
/**
* 给生产者推送数据的
*
* @param name
* @param size
*/
public void push(String name, String size) {
this.name = name;
try {
Thread.sleep(1000L);
} catch (InterruptedException e) {
e.printStackTrace();
}
this.size = size;
}
public void pop() {
try {
Thread.sleep(1000L);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("服装名称:" + this.name + " 尺码: " + this.size);
}
}
生产者与消费者出现数据紊乱的问题
1. 问题1:出现数据紊乱问题
-
解决方案:只要保证生产名字和尺码的过程中保持同步,中间不被消费者消费
-
同步方法/同步代码块/锁来保持同步性
-
2. 问题2:应该生产一个数据消费一个数据
-
应该交替出现,男士--XXL 女士--s 男士--xxl 女士--s
-
使用等待唤醒机制
-
线程通信
1. 线程通信(wait)和(notify) 方法介绍
-
wait():执行该方法的线程对象要释放同步锁,JVM 会把该线程放到等待池里面,等待其它的线程唤醒它
-
notify():执行该方法的线程唤醒在等待池中的线程,把线程转到锁池中去等待。
-
notifyAll():执行该方法的线程,唤醒在等待池中的所有线程,把这些线程转移到锁池中去等待。
-
注意点:这些方法,只能被同步监听锁对象锁(同步锁)调用
2. 同步监听锁对象(同步锁):多个线程有共同对象使用时,多个线程之间才会出现互斥现象,共同的这个对象就叫同步监听锁对象
3. 同步监听锁对象(同步锁):多个线程有共同对象使用时,多个线程之间才会出现互斥现象,共同的这个对象就叫同步监听锁对象
4. P线程和C线程S对象(同步锁),P,C线程如何通信(wait notify)
-
P线程执行S对象的同步方法,P线程持有S对象的锁,C线程是不是在S对象的锁池中等待。
-
P线程生产完,执行 wait() ,释放S对象的锁,进入S对象的等待池中去等待生产。
-
S对象锁池中等待的C线程获取S对象的锁,执行S对象的消费同步方法。
-
C线程消费结束,执行完S对象的同步消费方法时,执行notify()唤醒P线程,JVM把P从S对象等待池中移到S对象的锁池中,等待获取锁,C 线程释放锁,P获取锁,继续循环。
public class ShareResource {
private String name;
private String size;
private boolean isEmpty = true;//判断资源对象是否为空
/**
* 给生产者推送数据的
*
* @param name
* @param size
*/
synchronized public void push(String name, String size) {
try {
//判断资源对象是否为空,空的时候等待
while (!isEmpty){
this.wait();
}
this.name = name;
Thread.sleep(1000L);
this.size = size;
isEmpty = false;
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
this.notify();//唤醒一个消费者
}
}
synchronized public void pop() {
try {
//如果资源为空,消费者等待
while (isEmpty){
this.wait();
}
Thread.sleep(1000L);
System.out.println("服装名称:" + this.name + " 尺码: " + this.size);
isEmpty = true;
this.notify();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
5. Lock 和 Condition 接口:
-
wait 和 notify 只能被同步监听锁对象调用,否则报错,但是Lock 机制根本没有同步锁,也没有获取释放锁的逻辑。
-
使用Condition 接口对象的 await singnal signalAll 方法取代 Object 类中的 wait notify notifyAll 方法
public class ShareResource {
private String name;
private String size;
private boolean isEmpty = true;//判断资源对象是否为空
private Lock lock = new ReentrantLock();
private Condition condition = lock.newCondition();
/**
* 给生产者推送数据的
*
* @param name
* @param size
*/
public void push(String name, String size) {
lock.lock();//获取锁
try {
//判断资源对象是否为空,空的时候等待
while (!isEmpty){
condition.await();
}
this.name = name;
Thread.sleep(1000L);
this.size = size;
isEmpty = false;
condition.signalAll();
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
lock.unlock();//释放锁
}
}
public void pop() {
lock.lock();//上锁
try {
//如果资源为空,消费者等待
while (isEmpty){
condition.await();
}
Thread.sleep(1000L);
System.out.println("服装名称:" + this.name + " 尺码: " + this.size);
isEmpty = true;
condition.signalAll();
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
lock.unlock();//释放锁
}
}
}
建议:建议使用第二种方式
死锁
1. 多线程通信时,很容易出现死锁现象,死锁并且是不能解决的,只能避免。
- P线程等待有C线程持有的锁,而我们C线程又去等待P线程持有的锁,发生死锁现象,JVM不检测也不是图避免这种情况
2. 如何避免死锁:当我们多个线程去访问共享资源的时候 A,B,C,保证每一个线程都按照相同的顺序去访问。
3. Thread 类有一些过时的方法:
-
suspend() 使正在运行的线程放弃 CPU 暂停运行。
-
resume() 是暂停线程恢复运行
-
这两方法很容易导致死锁,不要去使用
-
P线程获取锁对象,去执行同步方法,如果C线程调用P线程的暂停方法,此时P就会放弃CPU但是不释放锁。
-
-
如何避免:上锁---释放锁
线程的生命周期
1. 生命周期:一个物品从出生---死亡
2. 线程的生命周期(Thread.State):
-
NEW:使用new 创建线程对象的时候,只分配了空间,调用 start() 方法的时候,线程启动
-
RUNNABLE:(可运行状态)使用了 start 之后,变成了两种状态
-
ready:准备就绪,等待 cpu 的调度
-
running :获取到了 cpu 的调度
-
-
BLOCKED:(阻塞的状态)运行中的线程,因为某些原因,放弃了 cpu 暂停运行,此时 jvm 不会给线程分配 cpu
-
当 P线程处于运行状态时,但是,没有获取到同步锁, JVM 就会把 P线程放到同步锁对象的锁池中去,P阻塞
-
线程运行中发出(IO请求),此时阻塞
-
-
WAITING:(等待的状态)等待状态只能被其它线程唤醒,
-
运行中的线程调用了 wait() 方法,此时 jvm 把当前的线程存放在对象等待池中
-
-
TIMED_WAITING:(计时等待)wait(long),sleep(long),就变成计时等待
-
线程运行过程中,调用上面方法,此时 JVM把当前线程存在对象等待池中
-
-
TERMINATED:(停止)表示线程结束了
-
正常的执行完线程
-
出现异常
-
定时器
1. Timer 里面有一个常用的方法
Timer timer = new Timer();
timer.schedule(new TimerTask() {
@Override
public void run() {
System.out.println("----");
}
},0,1000L);
线程组
1. 可以对线程集中管理,ThreadGroup
2. 用户创建线程对象时,可以通过构造器指定所属的线程组
ThreadGroup groups = new ThreadGroup("商品上架线程组");
ThreadGroup groups1 = new ThreadGroup("fihfiwehuif");
GoodsThread a = new GoodsThread(groups, "A");
a.start();
new GoodsThread(groups,"B").start();
new GoodsThread(groups1,"C").start();
new GoodsThread("efwefewfewfe").start();
public GoodsThread(ThreadGroup group, String name) {
super(group,name);
}
3. A线程中创建B线程,B线程默认加入A线程线程组
4. 默认创建的线程,都属于main 线程