*线程:
还会涉及到一些名词概念:
(程序,进程,线程,多进程,多线程,并发)
--进程: 是一个运行中的程序的实例。
--多进程:多个进程同时运行
进程的两个特点:
(1)是一个实体,都有自己独立的地址空间,分为文本区域,数据区域和堆栈。
文本区域用来存储编写的程序的代码,
数据区域用来存储运行时所需要的数据(动态分配的内存),
堆栈用来存储运行时涉及到的指令和本地变量
(2)是一个"运行中的程序",程序本身是一个没有生命的实体,只有当处理器
赋予它生命时,它才能称之为一个活动的实体,即进程。
进程是操作系统级别的基本单元。
通俗点说:进程就是操作系统运行的一个任务(一个应用程序运行时,就对应一个进程)
--线程的状态图解析:
(1) 新建状态: 即新建一个线程对象,设置好需要执行的任务
(2) 就绪状态: 调用线程的start方法,进入准备状态,等待cpu分配时间片段
(3) 运行状态: 当cpu将时间片段给了线程对象后,线程开始执行任务。
(4) 阻塞状态: 正在运行中的线程由于某种原因,放弃了cpu的使用权
即该线程放弃时间片段,进入阻塞状态。
阻塞状态分为三种:
1)等待阻塞: 运行中的线程调用wait方法时,jvm将此线程放入等待池中
2)同步阻塞: 运行中的线程想要获取同步的锁对象时,如果锁对象被其他占用,
则,jvm将此线程放入锁池中
3)其他阻塞: 当线程中执行到阻塞方法/Thread.sleep()/其他线程的join时,
该线程进行阻塞状态
(5) 当线程执行完任务后,表示结束。
--线程的创建方式(3种)
(1)继承Thread类,重写run方法(线程的任务体),定义任务内容。
然后调用start方法,用于启动线程。(切记,不是调用run方法)
(2)实现接口Runnable,重写run方法,定义任务内容,
然后将任务传给Thread对象,再由Thread调用strat方法,执行任务
(3)使用FutureTask创建线程,再使用Callable创建子类任务,
重写call方法(相当于run方法),再将Callable对象传给FutureTask,
再将FutureTask对象传给Thread对象,
调用start方法,启动线程
第二种方式与第一种比较:
(1)将线程对象和任务对象分开,降低了耦合度,便于维护
(2)避免了java中单继承的限制
(3)适合相同的任务代码块处理同一个资源
第三种方式: call方法带有返回值。
--线程API:
常用构造器:
Thread(Runnable r): 创建一个指定任务的线程对象
Thread(Runnable r,String name): 创建一个指定任务,并且指定名称的线程对象
Thread(String name): 创建一个指定名称的线程对象
常用方法: 下面有
练习:
桌子上总共有20个豆子,有两个人来取豆子,每个人每次只
能取一个豆子。并输出桌子上剩余的豆子数。
--线程的优先级:
1-10,10为最高级别,1为最低级别,5为默认级别
Thread.MIN_PRIORITY--最小优先级
Thread.MAX_PRIORITY--最高优先级
Thread.NORM_PRIORITY--默认优先级
--守护线程:(调用setDaemon()方法)
线程分两类:
1)普通线程(前台线程)
2)守护线程(后台线程)
当线程只剩下守护线程后,所有线程都结束。
------------------------------------------------------------------------------------------------------------------------
static sleep(long time):
线程的静态方法,用于使当前线程进入阻塞状态,时间为time毫秒。
time毫秒后,会进入就绪状态。如果期间被打断,会出现异常
InterruptException
join():
作用是将当前线程插入到某一个线程中,使某一个线程进入阻塞状态。
当前线程执行完后,另一个线程进入就绪状态。
=========================================================================================================
程序,进程,线程,多进程,多线程
(1)程序:可以实现多个功能的代码体。也叫软件。
(2)进程:有两个特点
--是一个实体:有自己的地址空间,如文本区域,数据区域,堆栈区域
--是一个运行中的程序,cpu赋予程序生命时,就是一个进程。
进程是操作系统的一个任务
(3)线程:是进程里的一个任务,是一个顺序执行流。
有自己独立的堆栈,与其他线程共享进程的地址空间
(4)多进程:针对于古老的操作系统来说,现在的操作系统都是多进程的。
可以同时运行多个程序
(5)多线程:一个进程中的多个任务,可以同时进行多个顺序执行流。
好处:
1)提高cpu的资源利用率
2)可以共享同一个资源(静态资源,同一个对象实例)
----------------------------------------------------------------------------------------------------------------------
*并发原理:
cpu在一个时间片段里,只能做一件事。微观上,cpu是将时间细分成
很多个小的时间片段,尽可能的将时间片段平均分给多个线程,所以
针对于某一个线程来说,是走走停停,断断续续的。但是在宏观上,
人类感觉不出,看似是这些线程是同时进行的,这就是并发原理。
线程并发出现在多线程中。
--线程的三种创建方式:
(1)继承Thread类,重写run方法,调用start方法,启动线程进入就绪状态
(2)实现Runnable接口,重写run方法,传给Thread对象....
(3)创建Callable的子类对象,重写call方法,传给FutureTask对象,再将
FutureTask对象传给Thread对象,.........
--线程的状态:
(1)新建状态: 线程的创建(任务的确定)
(2)就绪状态: 调用start()
(3)运行状态: cpu将时间片段给线程,执行run方法里的任务逻辑
(4)阻塞状态: 线程放弃cpu的时间片段,进入阻塞。
等待阻塞: wait()
同步阻塞: 要获取的锁对象,已经被占用。当前线程等待其他线程释放锁对象
其他阻塞: sleep(),join(),其他类的阻塞方法(sc.nextInt())
(5)死亡状态: 线程任务结束或者由于异常造成的run方法停止。
--常用构造器:
Thread(String name);
Thread(Runnable r)
Thread(Runnable r,String name)
--常用方法:
String getName()
long getId()
int getPriority()
State getState()
boolean isAlive()
boolean isDaemon()
boolean isInterrupt();
static Thread currentThread():返回当前正在运行的对象的引用
--线程调度:
多线程时,谁先执行是不可控的,是由cpu的线程调度来分配的。
但是我们可以通过线程的优先级来尽可能的让线程调度来调控线程
所需要的时间片段。
优先级:从1-10,越来越高。
1是最低的优先级: 对应的常量:MIN_PRIORITY
10是最高的优先级: 对应的常量:MAX_PRIORITY
5是默认的优先级: 对应的常量:NORM_PRIORITY
对应的方法:
void setPriority(int priority)
int getPriooity();
--守护线程:
线程共分两大类:
1)普通线程(前台线程)
2)守护线程(后台线程)
在只剩下守护线程时,会结束所有线程。
方法:
void setDaemon(boolean flag):
设置为true时,是守护线程
static void sleep(long time):
使当前线程放弃时间片段,进入阻塞状态,超时后,会进入就绪状态。
如果没有超时,而是被打断,会出现检查性异常:InterruptException
void interrupt():
打断阻塞状态下的线程对象。
void join():
将当前线程A加入到线程B中,线程B进入阻塞状态,
直到线程A结束,线程B进入就绪状态,等待被分配时间片段。
练习:
两个线程A和B:
线程A的任务是计算1到100的和。
线程B的任务是获取线程A计算的结果。
static void yield():
线程对象让步的功能:让出时间片段,此线程进入就绪状态。
=======================================================================
*同步锁:
当多个线程操作临界资源时,可能会出现线程安全隐患问题。
临界资源可能是:
(1)某一个静态变量
(2)某一个实例变量
如果想解决这样的问题,需要使用同步操作。
--异步操作:多线程的并发操作,相当于各干各的
--同步操作:相当于一个做完,另一个再做。
线程在内部提供了一个内置的"锁机制"保证原子性,用于线程进行同步操作。
--锁需要两点:
(1)锁是一个对象,
(2)如果想进行同步,多个线程操作的必须是“同一个锁”
synchronized(锁对象的引用){
需要同步的代码块
}
--锁机制:
当一个线程进入同步的代码块后,就会获得锁对象的使用权。
其他线程如果执行到此处,会发现锁对象被占用,只能处于等待状态(锁池),
当线程执行完同步的代码块后或者出现异常,都会自动释放锁。
--合适的锁对象:
必须是一个引用类型,而且必须使多个线程都可以使用这个锁对象,
因此this对象比较适合
--------------------------------------------------------------------------------------------------------------------------------
--同步方法:给方法上锁
--同步代码块的范围:
(1)可以是方法内的一部分代码,可以也是全部代码(相当于给方法上了锁)
(2)成员方法上添加修饰词synchronized,锁对象为this
如果一个类的所有成员方法都使用了同步关键字,
当某一个线程操作了其中一个方法,另外的线程即使操作的不是这个方法,
也会进入锁池状态
(3)静态方法上也可以添加synchronized,锁对象为类对象,
"调用方法:类名.class,每一种类都有一个唯一的类对象"
*同步代码块内:
(1)尽可能的不要使用sleep()和yield(),
因为比较占cpu资源
(2)同步块越小越好,省cpu的资源
---------------------------------------------------------------------------------------------------------------------------------
--wait() / notify(),notifyAll():
上述的方法都是Object类型提供的,用来调控线程的状态的。
使用位置必须是同步块中,如果不是同步块中,会报异常
wait():
当前获取锁对象的线程准备释放锁,给其他线程获取锁的机会。
wait(long time):
当前获取锁对象的线程如果没有被通知,在延迟time毫秒后,自动释放锁对象
wait(long time,int naons):
功能一样,只不过比上一个方法延迟的时间更加精确。
notify()/notifyAll():
当前获取锁对象的线程准备释放锁,使用此方法通知处于使用wait方法等待的线程,
notify():
只会随机通知等待线程中的其中一个。
notifyAll():
通知所有等待的线程来竞争锁。
=======================================================================
*生产者--消费者--仓库模式:此模式脱离了仓库没有任何意义。
(1)仓库用来存储数据。
(2)仓库不满的情况下,生产者可以生产
(3)仓库中满足消费者的需求时,消费者就可以消费
/*作业1:
第一个线程输出1,2,3,4,5
第二个线程输出6,7,8,9,10
第三个线程输出11,12,13,14,15
第一个线程输出16,17,18,19,20
第二个线程输出..........
第三个线程输出........
直到输入75停止。
作业2:
模拟小张一家四口(小张,小张媳妇,小张他爸,小张他妈)
分别拿着小张的银行卡去银行存取钱。
*/
===============================================================================================================================================================================================
===================================================
前提:有多个线程时
并发操作:多个线程同时开启,微观上断断续续,宏观上同时发生
断断续续:同一个方法内的两行代码不一定是两个挨着的时间片段
同步操作:在并发的基础上,同一个方法内的两行代码执行时间片段
可以不挨着,但是其他线程不能对这两行代码的执行权 ,
保证了代码的原子性。即这两行代码是同步的,当前线程执行完后,
其他线程才有执行权。
想实现同步操作,提供了一个锁机制:
我们将需要同步的代码加上一个内置锁对象,当某一个线程
执行到此代码时,会获取锁对象,其他线程需要等待。当获取锁对象的
线程执行完同步块(或者是因为异常)都会释放锁对象。其他线程
通过cpu的线程调用才有机会获取锁对象的使用权
synchronized(锁对象){
}
锁对象:多个线程一定要使用同一个锁,否则没有记性同步操作
========================================================================
*线程池:
(1)如果每个任务都需要创建线程对象,内存开销大
(2)方便管理线程对象。
--线程池的原理: 就是一些线程的集合,
线程的状态不是死亡状态,
当线程池接收外面的任务时,
线程池的管理器会查看是否有空闲线程,
如果有,就会将任务分配给它,
如果没有,任务处于等待队列中.
--线程池的类型:ExecutorService
另外一个类Executors里提供了多个静态方法,
来获取线程池对象
方法1:
newSingleThreadExecutor():
获取单个线程的线程池对象,内部维护了一个无界队列用于存储任务
方法2:
newFixedThreadPool(int nThreads):
创建一个固定数量线程的线程池,维护一个为无界队列
方法3:
newCachedThreadPool():
创建一个可以根据需求来创建新线程的线程池对象,
如果有可重用的,会优先使用。
方法4:
newScheduledThreadPool(int corePoolSize):
创建一个线程池,可以进行设置延迟或者是定时来执行任务