进程的概念
进程就是正在运行的程序,他会占用对应的内存区域,由CPU进行执行与计算
进程的特点
独立性:进程是系统中独立存在的实体,它可以拥有自己独立的资源,每个进程都拥有自己私有的地址空间,在没有经过进程本身允许的情况下,一个用户进程不可以直接访问其他进程的地址空间
动态性: 进程与程序的区别在于,程序只是一个静态的指令集合,而进程是一个正在系统中活动的指令集合,程序加入了时间的概念以后,称为进程,具有自己的生命周期和各种不同的状态,这些概念都是程序所不具备的
并发性:多个进程可以在单个处理器CPU上并发执行,多个进程之间不会互相影响
线程:
线程是操作系统OS能够进行运算调度的最小单位,它被包含在进程之中,是进程中的实际运作单位一个进程可以开启多个线程,其中有一个主线程来调用本进程中的其他线程,我们看到的进程的切换,切换的也是不同进程的主线程
多线程可以让同一个进程同时并发处理多个任务,相当与扩展了进程的功能
进程与线程的关系
一个操作系统中可以有多个进程,一个进程中可以包含一个线程也可以包含多个线程
?每个线程在共享同一个进程中的内存的同时,又有自己独立的内存空间
多线程的特性
1.随机性
表面上看多个进程是同时运行的但实际上,一个CPU只能执行一个进程中的一个线程
这涉及到了CPU分时调度
时间片,即CPU分配给各个线程的一个时间段,即该线程被允许运行的时间,如果在时间片用完时线程还在执行那么CPU将被剥夺并分配给另一个线程,,将当前线程挂起,如果线程在时间片用完之前阻塞或结束,则CPU当即进行切换,从而避免cpu资源浪费,当再次切换到之前挂起的线程,恢复现场,继续执行
我们无法选择OS选择执行哪些线程,os底层有自己的算法规则
- FCFS(First Come First Service 先来先服务算法)
- SJS(Short Job Service短服务算法)
线程的状态:
1简单的"三态模型"
就绪状态(可运行):线程已经准备好运行,只要获得CPU,就可立即执行
执行状态:线程已经获得CPU,其程序正在运行的状态
阻塞状态:正在运行的线程由于某些事件(I/O请求等)暂时无法执行的状态,即线程执行阻塞
?五态模型:
?在三态模型的基础上添加了两种状态
1.创建状态:线程的创建比较复杂,需要先申请PCB,然后为该线程运行分配必须的资源,并将该线程转为就绪状态插入到就绪队列中
2.终止状态:等待os进行善后处理,最后将PCB清零,并将PCB返回给系统
线程的五种状态(线程的生命周期):
1.新建状态:当线程对象创建后就进入了新建状态Thread t = new MyThread();
2.就绪状态:当调用对象的start()方法,线程即为进入就绪状态
处于就绪状态的线程,只是说明线程已经做好准备,随时等待cpu调度执行,并不是执行了tstart()线程就会立即执行
3.运行状态:当CPU调度了处于就绪状态的线程时(也就是分配到了时间片),此线程才是真正的执行,即进入到运行状态
就绪状态是进入运行状态的唯一入口,也就是线程想要进入运行状态,先的处于就绪状态
4.阻塞状态:处于运行状态中的线程由于某种原因,暂时放弃对cpu的使用权,停止执行,此时进入阻塞状态,直到其进入就绪状态才有机会被cpu选中再次执行
阻塞状态产生的原因不同分为3种
1)等待阻塞:运行状态中的线程执行wait()方法,本线程进入到等待阻塞状态
2)同步阻塞:线程在获取synchronized同步锁失败(因为锁被其他线程占用),它会进入同步阻塞状态
3)其他阻塞:调用线程的sleep()或者join()或发出了I/o请求时,线程会进入到阻塞状态,当sleep()状态超时.join()等待线程终止或者超时或者i/o处理完毕时线程重新转入就绪状态
5.死亡状态(Dead):线程执行完了或者因异常退出了run()方法,该线程结束生命周期
Thread类本质上是实现了Runnable接口的一个实例,代表一个线程的实例
启动线程的唯一方法就是通过Thread类的start()实例方法
start()方法是一native方法,它将通知底层操作系统,.最终由操作系统启动一个新线程,操作系统将执行run()
这种方式实现的多线程很简单,通过自己的类直接extends Thread,并重写run()方法,就可以自动启动新线程并执行自己定义的run()方法
模拟开启多个线程,每个线程调用run()方法.
两种实现方式的比较
继承Thread类
优点: 编写简单,如果需要访问当前线程,无需使用Thread.currentThread()方法,直接使用this即可获得当前线程
缺点: 自定义的线程类已继承了Thread类,所以后续无法再继承其他的类
实现Runnable接口
优点: 自定义的线程类只是实现了Runnable接口或Callable接口,后续还可以继承其他类,在这种方式下,多个线程可以共享同一个target对象,所以非常适合多个相同线程来处理同一份资源的情况,从而可以将CPU、代码、还有数据分开(解耦),形成清晰的模型,较好地体现了面向对象的思想
缺点: 编程稍微复杂,如想访问当前线程,则需使用Thread.currentThread()方法
判断线程安全问题的条件
在多线程程序中+有共享数据+多条语句操作共享数据
eg:多线程的场景和共享数据的条件是改变不了的(就像4个窗口一起卖100张票,这个是业务)
所以思路可以从第3点"多条语句操作共享数据"入手,既然是在这多条语句操作数据过程中出现了问题
那我们可以把有可能出现问题的代码都包裹起来，一次只让一个线程来执行
同步与异步
那怎么"把有可能出现问题的代码都包裹起来"呢?我们可以使用synchronized关键字来实现同步效果
也就是说,当多个对象操作共享数据时,可以使用同步锁解决线程安全问题,被锁住的代码就是同步的
接下来介绍下同步与异步的概念:
同步：体现了排队的效果，同一时刻只能有一个线程独占资源，其他没有权利的线程排队。
坏处就是效率会降低，不过保证了安全。
异步：体现了多线程抢占资源的效果，线程间互相不等待，互相抢占资源。
坏处就是有安全隐患,效率要高一些。
synchronized同步关键字
synchronized (锁对象){
需要同步的代码(也就是可能出现问题的操作共享数据的多条语句);
}
同步效果的使用有两个前提:
- 前提1：同步需要两个或者两个以上的线程(单线程无需考虑多线程安全问题)
- 前提2：多个线程间必须使用同一个锁(我上锁后其他人也能看到这个锁,不然我的锁锁不住其他人,就没有了上锁的效果)
特点
1.synchronized同步关键字可以用来修饰代码块,称为同步代码块,使用的锁对象类型任意，但注意：必须唯一！
2.synchronized同步关键字可以用来修饰方法,称为同步方法
3.同步的缺点是会降低程序的执行效率，但我们为了保证线程的安全,有些性能是必须要牺牲的
4.但是为了性能,加锁的范围需要控制好,比如我们不需要给整个商场加锁,试衣间加锁就可以了
为什么同步代码块的锁对象可以是任意的同一个对象,但是同步方法使用的是this呢?
因为同步代码块可以保证同一时刻只用一个线程进入
但同步方法不可以保证同一时刻只能有一个线程调用,所以本类代指对象this来确保同步
package cn.tedu.tickets;
/*本类用于改造多线程售票案例，解决数据安全问题*/
public class TestThreadV2 {
? ? public static void main(String[] args) {
? ? ? ? //5.创建多个线程对象并以多线程的方式运行
? ? ? ? TickectT2 t1 = new TickectT2();
? ? ? ? TickectT2 t2 = new TickectT2();
? ? ? ? TickectT2 t3 = new TickectT2();
? ? ? ? TickectT2 t4 = new TickectT2();
? ? ? ? t1.start();
? ? ? ? t2.start();
? ? ? ? t3.start();
? ? ? ? t4.start();
? ? }
}
//1.自定义多线程类
class TickectT2 extends Thread {
? ? //3.新增成员变量用来保存票数
? ? static int tickets = 100;
? ? //static Object o = new Object();
? ? //2.添加重写的run()来完成业务
? ? @Override
? ? public void run() {
? ? ? ? //3.创建循环结构用来卖票
? ? ? ? while (true) {
? ? ? ? ? ? //Ctrl+Alt+L调整代码缩进
? ? ? ? ? ? //7.添加同步代码块，解决数据安全问题
? ? ? ? ? ? //synchronized (new Object()) {
? ? ? ? ? ? /*static的Object的对象o这种写法也可以*/
? ? ? ? ? ? //synchronized (o) {
? ? ? ? ? ? /*我们每通过class关键字创建一个类，就会在工作空间中生成一个唯一对应的类名.class字节码文件
? ? ? ? ? ? * 这个类名.class对应的对象我们称之为这个类的字节码对象
? ? ? ? ? ? * 字节码对象极其重要，是反射技术的基石，字节码对象中包含了当前类所有的关键信息
? ? ? ? ? ? * 所以，用这样一个唯一且明确的对象作为同步代码块的锁对象，再合适不过了*/
? ? ? ? ? ? synchronized (TickectT2.class) {/*比较标准的写法*/
? ? ? ? ? ? ? ? if(tickets > 0){
? ? ? ? ? ? ? ? ? ? //6.添加线程休眠，暴露问题
? ? ? ? ? ? ? ? ? ? try {
? ? ? ? ? ? ? ? ? ? ? ? Thread.sleep(10);//让线程休眠，增加线程状态切换的频率
? ? ? ? ? ? ? ? ? ? } catch (InterruptedException e) {
? ? ? ? ? ? ? ? ? ? ? ? e.printStackTrace();
? ? ? ? ? ? ? ? ? ? }
? ? ? ? ? ? ? ? ? ? //4.1打印当前正在售票的线程名与票数-1
? ? ? ? ? ? ? ? ? ? System.out.println(getName() + "=" + tickets--);
? ? ? ? ? ? ? ? }
? ? ? ? ? ? ? ? //4.2给程序设置一个出口，没有票的时候就停止卖票
? ? ? ? ? ? ? ? if (tickets <= 0) break;
? ? ? ? ? ? }
? ? ? ? }
? ? }
}
版本问题
StringBuffer JDK1.0
加了synchronized ,性能相对较低(要排队,同步),安全性高
StringBuilder JDK1.5
去掉了synchronized,性能更高(不排队,异步),存在安全隐患
线程池
package cn.tedu.tickets;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/*本类用于测试线程池*/
public class TestThreadPool {
? ? public static void main(String[] args) {
? ? ? ? //5.创建接口实现类TicketR3类的对象作为目标业务对象
? ? ? ? TicketR3 target = new TicketR3();
? ? ? ? /*Executors是用来辅助创建线程池的工具类对象
? ? ? ? * 常用方法是newFixedThreadPool(int)这个方法可以创建指定数目的线程池对象
? ? ? ? * 创建出来的线程池对象是ExecutorService:用来存储线程的池子，负责：新建/启动/关闭线程*/
? ? ? ? //6.使用Executors工具创建一个最多有5个线程的线程池对象ExecutorService池对象
? ? ? ? ExecutorService pool = Executors.newFixedThreadPool(5);
? ? ? ? for (int i = 0; i < 5; i++) {
? ? ? ? ? ? /*execute()让线程池中的线程来执行业务，每次调用都会将一个线程加入到就绪队列*/
? ? ? ? ? ? pool.execute(target);/*本方法的参数就是你要执行的业务，也就是目标业务类对象*/
? ? ? ? }
? ? }
}
//同步锁问题解决方案笔记：1.4.1从26行复制到58行，TicketR2改成TicketR3
//1.创建自定义多线程类
class TicketR3 implements Runnable {
? ? //3.定义成员变量，保存票数
? ? int tickets = 100;
? ? //创建锁对象
? ? Object o = new Object();
? ? //2.实现接口中未实现的方法，run()中放着的是我们的业务
? ? @Override
? ? public void run() {
? ? ? ? //4.通过循环结构完成业务
? ? ? ? while (true) {
? ? ? ? ? ? /*3.同步代码块：synchronized(锁对象){会出现安全隐患的所有代码}
? ? ? ? ? ? ?* 同步代码块在同一时刻，同一资源只会被一个线程独享*/
? ? ? ? ? ? /*这种写法不对，相当于每个线程进来的时候都会new一个锁对象，线程间使用的并不是同一把锁*/
? ? ? ? ? ? //synchronized (new Object()){
? ? ? ? ? ? //修改同步代码块的锁对象为成员变量o,因为锁对象必须唯一
? ? ? ? ? ? synchronized (o) {//同步代码块解决的是重卖的问题
? ? ? ? ? ? ? ? //如果票数>0就卖票
? ? ? ? ? ? ? ? if (tickets > 0) {
? ? ? ? ? ? ? ? ? ? try {
? ? ? ? ? ? ? ? ? ? ? ? Thread.sleep(10);
? ? ? ? ? ? ? ? ? ? } catch (InterruptedException e) {
? ? ? ? ? ? ? ? ? ? ? ? e.printStackTrace();
? ? ? ? ? ? ? ? ? ? }
? ? ? ? ? ? ? ? ? ? //4.1打印当前正在售票的线程名以及票数-1
? ? ? ? ? ? ? ? ? ? System.out.println(Thread.currentThread().getName() + "=" + tickets--);
? ? ? ? ? ? ? ? }
? ? ? ? ? ? ? ? //4.2退出死循环--没票的时候就结束
? ? ? ? ? ? ? ? if (tickets <= 0) break;
? ? ? ? ? ? }
? ? ? ? }
? ? }
}
常见的锁
悲观锁：像它的名字一样，对于并发间操作产生的线程安全问题持悲观状态.
悲观锁认为竞争总是会发生，因此每次对某资源进行操作时，都会持有一个独占的锁,就像synchronized,不管三七二十一，直接上了锁就操作资源了。
乐观锁：还是像它的名字一样，对于并发间操作产生的线程安全问题持乐观状态.
乐观锁认为竞争不总是会发生，因此它不需要持有锁，将”比较-替换”这两个动作作为一个原子操作尝试去修改内存中的变量，如果失败则表示发生冲突，那么就应该有相应的重试逻辑。
?
synchronized 互斥锁（悲观锁，有罪假设）
采用synchronized修饰符实现的同步机制叫做互斥锁机制，它所获得的锁叫做互斥锁。
每个对象都有一个monitor(锁标记)，当线程拥有这个锁标记时才能访问这个资源，没有锁标记便进入锁池。任何一个对象系统都会为其创建一个互斥锁，这个锁是为了分配给线程的，防止打断原子操作。每个对象的锁只能分配给一个线程，因此叫做互斥锁。
ReentrantLock 排他锁（悲观锁，有罪假设）
ReentrantLock是排他锁，排他锁在同一时刻仅有一个线程可以进行访问，实际上独占锁是一种相对比较保守的锁策略，在这种情况下任何“读/读”、“读/写”、“写/写”操作都不能同时发生，这在一定程度上降低了吞吐量。然而读操作之间不存在数据竞争问题，如果”读/读”操作能够以共享锁的方式进行，那会进一步提升性能。
ReentrantReadWriteLock 读写锁（乐观锁，无罪假设）
因此引入了ReentrantReadWriteLock，顾名思义，ReentrantReadWriteLock是Reentrant（可重入）Read（读）Write（写）Lock（锁），我们下面称它为读写锁。
读写锁内部又分为读锁和写锁，读锁可以在没有写锁的时候被多个线程同时持有，写锁是独占的。
读锁和写锁分离从而提升程序性能，读写锁主要应用于读多写少的场景
尝试用读写锁改造售票案例
package cn.tedu.thread;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.ReentrantReadWriteLock;
/**
?* 本类用于改造售票案例,使用可重入读写锁
?* ReentrantReadWriteLock
?* */
public class TestSaleTicketsV3 {
?? ?public static void main(String[] args) {
?? ??? ?SaleTicketsV3 target = new SaleTicketsV3();
?? ??? ?Thread t1 = new Thread(target);
?? ??? ?Thread t2 = new Thread(target);
?? ??? ?Thread t3 = new Thread(target);
?? ??? ?Thread t4 = new Thread(target);
?? ??? ?t1.start();
?? ??? ?t2.start();
?? ??? ?t3.start();
?? ??? ?t4.start();
?? ?}
}
class SaleTicketsV3 implements Runnable{
?? ?static int tickets = 100;
?? ?//1.定义可重入读写锁对象,静态保证全局唯一
?? ?static ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
?? ?@Override
?? ?public void run() {
?? ??? ?while(true) {
?? ??? ??? ?//2.在操作共享资源前上锁
?? ??? ??? ?lock.writeLock().lock();
?? ??? ??? ?try {
?? ??? ??? ??? ?if(tickets > 0) {
?? ??? ??? ??? ??? ?try {
?? ??? ??? ??? ??? ??? ?Thread.sleep(10);
?? ??? ??? ??? ??? ?} catch (InterruptedException e) {
?? ??? ??? ??? ??? ??? ?e.printStackTrace();
?? ??? ??? ??? ??? ?}
?? ??? ??? ??? ??? ?System.out.println(Thread.currentThread().getName() + "=" + tickets--);
?? ??? ??? ??? ?}
?? ??? ??? ??? ?if(tickets <= 0) break;
?? ??? ??? ?} catch (Exception e) {
?? ??? ??? ??? ?e.printStackTrace();
?? ??? ??? ?}finally {
?? ??? ??? ??? ?//3.finally{}中释放锁,注意一定要手动释放,防止死锁,否则就独占报错了
?? ??? ??? ??? ?lock.writeLock().unlock();
?? ??? ??? ?}
?? ??? ?}
?? ?}
}?
互斥锁与读写锁的区别
用sychronized修饰的方法或者语句块在代码执行完之后锁会自动释放，而是用Lock需要我们手动释放锁，所以为了保证锁最终被释放(发生异常情况)，要把互斥区放在try内，释放锁放在finally内！
与互斥锁相比，读-写锁允许对共享数据进行更高级别的并发访问。虽然一次只有一个线程（writer 线程）可以修改共享数据，但在许多情况下，任何数量的线程可以同时读取共享数据（reader 线程）从理论上讲，与互斥锁定相比，使用读-写锁允许的并发性增强将带来更大的性能提高
?
