一、线程的基本概念
1.1 进程
任何的软件存储在磁盘中,运行软件的时候,OS(操作系统)使用IO技术,将磁盘中的软件的文件加载到内存,程序才能运行。
进程的概念 : 应用程序(如typerpa、IDEA)运行的时候进入到内存,程序在内存中占用的内存空间就是进程。
1.2 线程
线程(Thread) : 在内存和CPU之间,建立一条连接通路,CPU可以到内存中取出数据进行计算,这个连接的通路,就是线程。
一个内存资源 : 一个独立的进程,进程中可以开启多个线程 (多条通路)。
并发: 同一个时刻多个线程同时操作了同一个数据
并行: 同一个时刻多个线程同时执行不同的程序
1.3 进程与线程的区别
(1)进程是操作系统资源分配和调度的一个独立单元,而线程是CPU调度的基本单元。
(2)同一个进程中可以包括多个线程,并且线程共享整个进程的资源(寄存器、堆栈、上下文),一个进程至少包括一个线程。
二、多线程的实现方式一:继承Thread类
一切都是对象,线程也是对象,Thread类是线程对象的描述类。
2.1 步骤
1、 定义类继承Thread类
2、子类重写run()
方法
3、创建子类对象
4、调用子类对象的方法start()
开启线程
代码:
//- 定义类继承Thread
//- 子类重写方法run
public class SubThread extends Thread {
public void run(){
for(int x = 0 ; x < 50 ;x++)
System.out.println("run..."+x);
}
}
public static void main(String[] args) {
//创建线程程序
SubThread subThread = new SubThread();
//调用子类对象的方法start()启动线程
//启动线程,JVM调用方法run
subThread.start();
for(int x = 0 ; x < 50 ;x++)
System.out.println("main..."+x);
}
2.2 线程的内存图
2.3 Thread类的方法
- Thread类的方法
String getName()
返回线程的名字
public class ThreadName extends Thread {
public void run (){
System.out.println("线程名字:: "+ super.getName());
}
}
public static void main(String[] args) {
ThreadName threadName = new ThreadName();
//threadName.setName("旺财");
threadName.start();
ThreadName threadName1 = new ThreadName();
//threadName1.setName("小强");
threadName1.start();
}
- Thread类静态方法 :
static Thread currentThread()
- 静态调用,作用是放回当前的线程对象
- "当前" , 当今皇上. 本地主机
//获取当前线程对象,拿到运行main方法的线程对象
Thread thread = Thread.currentThread();
System.out.println("name::"+thread.getName());
- Thread类的方法
join()
- 解释:执行join()方法的线程,他不结束,其它线程运行不了
public static void main(String[] args) throws InterruptedException {
JoinThread t0 = new JoinThread();
JoinThread t1 = new JoinThread();
t0.start();
t0.join();
t1.start();
}
- Thread类的方法
static yield()
- 线程让步,线程把执行权让出
public void run() {
for(int x = 0 ; x < 50 ;x++){
Thread.yield();
System.out.println(Thread.currentThread().getName()+"x.."+x);
}
}
三、多线程的实现方式二:实现Runnable接口
3.1 步骤
1、定义类实现Runnable接口
2、重写run()
方法
3、创建Thread类对象
- Thread类的构造方法中,传递Runnable接口的实现类对象
4、调用Thread类的start()
方法开启线程
示例代码:
//- 定义类实现接口
// - 重写接口的抽象方法run()
public class SubRunnable implements Runnable{
@Override
public void run() {
for(int x = 0 ; x < 50 ;x++){
System.out.println(Thread.currentThread().getName()+"x.."+x);
}
}
}
public static void main(String[] args) {
//创建接口实现类对象
Runnable r = new SubRunnable();
//创建Thread对象,构造方法传递接口实现类
Thread t0 = new Thread(r);
t0.start();
for(int x = 0 ; x < 50 ;x++){
System.out.println(Thread.currentThread().getName()+"x.."+x);
}
}
3.2 实现接口的好处
接口实现好处是设计上的分离效果 : 线程要执行的任务和线程对象本身是分离的。
继承Thread重写方法run() : Thread是线程对象,run()是线程要执行的任务
实现Runnable接口 : 方法run()在实现类,和线程无关。创建Thread类传递接口的实现类对象,线程的任务和Thread没有联系,,实现解耦操作。
四、线程安全问题
4.1 线程安全如何发生的
当满足以下两个条件时,会出现线程安全问题
① 存在多个线程共享同一个资源(成员变量)
② 有多句代码操作共享数据
线程执行调用方法run,同一个资源是堆内存的。
4.2 售票案例
以下代码是一个线程不安全的示例
/**
* 票源对象,需要多个线程同时操作
*/
public class Ticket implements Runnable {
//定义票源
private int tickets = 100;
@Override
public void run() {
while (true) {
if (tickets > 0) {
try {
Thread.sleep(10);//线程休眠,暂停执行
}catch (Exception ex){}
System.out.println(Thread.currentThread().getName()+" 出售第" + tickets + "张");
tickets--;
}else
break;;
}
}
}
public static void main(String[] args) {
Ticket ticket = new Ticket();
//创建3个窗口,3个线程
Thread t0 = new Thread(ticket);
Thread t1 = new Thread(ticket);
Thread t2 = new Thread(ticket);
t0.start();
t1.start();
t2.start();
}
解决线程的安全问题 : 当一个线程没有完成全部操作的时候,其它线程不能操作
4.3 同步代码块
同步代码块可以解决线程安全问题 : 格式 synchronized关键字
synchronized(任意对象){
//线程操作的共享资源
}
任意对象 : 在同步中这个对象称为对象锁,简称锁。官方的文档称为 对象监视器
4.4 同步代码块的执行原理
同步代码块的执行原理 : 关键点就是对象锁
- 线程执行到同步代码块,判断锁是否存在
- 如果锁存在,获取到锁,进入到同步代码块中执行
- 执行完毕,线程出去同步代码块,将锁对象归还
- 线程执行到同步代码块,判断锁所否存在
- 如果锁不存在,线程只能在同步代码块这里等待锁的到来
使用同步 : 线程要先判断锁,然后获取锁,出去同步要释放锁, 增加了许多步骤,因此线程安全运行速度慢。 牺牲性能,不能牺牲数据安全。
4.5 同步方法
当一个方法中所有代码都是线程操作的共享内容时,可以在方法的定义上添加同步的关键字 synchronized , 这就是同步方法,或者称为同步的函数。
静态同步方法的对象锁:类名.class
@Override
public void run() {
while (true)
sale();
}
private static synchronized void sale(){
// synchronized (Ticket.class) {
if (tickets > 0) {
try {
Thread.sleep(20);//线程休眠,暂停执行
} catch (Exception ex) {
}
System.out.println(Thread.currentThread().getName() + " 出售第" + tickets + "张");
tickets--;
}
// }
}
五、死锁
死锁程序 : 多个线程同时争夺同一个锁资源,出现的程序假死现象.
面试点 : 考察开发人员是否充分理解同步代码的执行原理
同步代码块 : 线程判断锁,获取锁,释放锁,不出代码,锁不释放。
完成死锁的案例 : 同步代码块的嵌套
死锁代码:
/**
* 实现死锁程序
*/
public class ThreadDeadLock implements Runnable{
private boolean flag ;
public ThreadDeadLock(boolean flag){
this.flag = flag;
}
@Override
public void run() {
while (true){
//同步代码块的嵌套
if (flag){
//先进入A锁同步
synchronized (LockA.lockA){
System.out.println("线程获取A锁");
//在进入另一个同步B锁
synchronized (LockB.lockB){
System.out.println("线程获取B锁");
}
}
}else {
//先进入B锁同步
synchronized (LockB.lockB){
System.out.println("线程获取B锁");
//再进入另一个同步锁A锁
synchronized (LockA.lockA){
System.out.println("线程获取A锁");
}
}
}
}
}
}
public class LockA {
public static LockA lockA = new LockA();
}
public class LockB {
public static LockB lockB = new LockB();
}
public static void main(String[] args) {
ThreadDeadLock threadDeadLock = new ThreadDeadLock(true);
ThreadDeadLock threadDeadLock2 = new ThreadDeadLock(false);
new Thread(threadDeadLock).start();
new Thread(threadDeadLock2).start();
}
六、JDK5新特性Lock锁
JDK5新的特性 : java.util.concurrent.locks包。定义了接口Lock。
Lock接口替代了synchronized,可以更加灵活
- Lock接口的方法
- void lock() 获取锁
- void unlock()释放锁
- Lock接口的实现类ReentrantLock
/**
* 优化为juc包的接口Lock
*/
public class Ticket implements Runnable {
//定义票源
private int tickets = 100;
//获取Lock接口的实现类对象
private Lock lock = new ReentrantLock();
@Override
public void run() {
while (true)
sale();
}
private void sale(){
//获取锁
lock.lock();
if (tickets > 0) {
try {
Thread.sleep(20);//线程休眠,暂停执行
} catch (Exception ex) {
}
System.out.println(Thread.currentThread().getName() + " 出售第" + tickets + "张");
tickets--;
}
//释放锁
lock.unlock();
}
}
七 、线程通信
线程与线程之间不是相互独立的个体,它们彼此之间需要相互通信和协作,最典型的例子就是生产者-消费者问题:当队列满时,生产者需要等待队列有空间才能继续往里面放入商品,而在等待的期间内,生产者必须释放对临界资源(即队列)的占用权。因为生产者如果不释放对临界资源的占用权,那么消费者就无法消费队列中的商品,就不会让队列有空间,那么生产者就会一直无限等待下去。因此一般情况下,当队列满时,会让生产者交出对临界资源的占用权,并进入挂起状态。然后等待消费者消费了商品,然后消费者通知生产者队列有空间了。同样地,当队列空时,消费者也必须等待,等待生产者通知它队列中有商品了。这种互相通信的过程就是线程间的协作。
7.1 生产者消费者问题
创建2个线程,一个线程表示生产者,另一个线程表示消费者。
案例
/**
* 定义资源对象
* 成员 : 产生商品的计数器
* 标志位
*/
public class Resource {
int count ;
boolean flag ;
}
/**
* 生产者线程
* 资源对象中的变量++
*/
public class Produce implements Runnable{
private Resource r ;
public Produce(Resource r) {
this.r = r;
}
@Override
public void run() {
while (true){
synchronized (r) {
//判断标志位,是否允许生产
//flag是true,生产完成,等待消费
if (r.flag )
//无限等待
try{ r.wait();
}catch (Exception ex){}
r.count++;
System.out.println("生产第" + r.count + "个");
//修改标志位,已经生产了,需要消费
r.flag = true;
//唤醒消费者线程
r.notify();
}
}
}
}
/**
* 消费者线程
* 资源对象中的变量输出打印
*/
public class Customer implements Runnable{
private Resource r ;
public Customer(Resource r) {
this.r = r;
}
@Override
public void run() {
while (true){
synchronized (r) {
//是否要消费,判断标志位 ,允许消费才能执行
if (!r.flag )
//消费完成,不能再次消费,等待生产
try{r.wait();}catch (Exception ex){}
System.out.println("消费第" + r.count);
//消费完成后,修改标志位,变成已经消费
r.flag = false;
//唤醒生产线程
r.notify();
}
}
}
}
public static void main(String[] args) {
Resource r = new Resource();
//接口实现类,生产的,消费的
Produce produce = new Produce(r);
Customer customer = new Customer(r);
//创建线程
new Thread(produce).start();
new Thread(customer).start();
}
7.2 wait/notify机制
线程通信的方法 wait()
notify()
- 方法的调用必须写在同步中
- 调用者必须是作为锁的对象
- wait(),notify()为什么要定义在Object类
- 同步中的锁,是任意对象,任何类都继承Object
案例实现线程同步:
/**
* 定义资源对象
* 成员 : 产生商品的计数器
* 标志位
*/
public class Resource {
private int count ;
private boolean flag ;
//消费者调用
public synchronized void getCount() {
//flag是false,消费完成,等待生产
if (!flag)
//无限等待
try{this.wait();}catch (Exception ex){}
System.out.println("消费第"+count);
//修改标志位,为消费完成
flag = false;
//唤醒对方线程
this.notify();
}
//生产者调用
public synchronized void setCount() {
//flag是true,生产完成,等待消费
if (flag)
//无限等待
try{this.wait();}catch (Exception ex){}
count++;
System.out.println("生产第"+count+"个");
//修改标志位,为生产完成
flag = true;
//唤醒对方线程
this.notify();
}
}
/**
* 消费者线程
* 资源对象中的变量输出打印
*/
public class Customer implements Runnable{
private Resource r ;
public Customer(Resource r) {
this.r = r;
}
@Override
public void run() {
while (true) {
r.getCount();
}
}
}
/**
* 生产者线程
* 资源对象中的变量++
*/
public class Produce implements Runnable{
private Resource r ;
public Produce(Resource r) {
this.r = r;
}
@Override
public void run() {
while (true) {
r.setCount();
}
}
}
7.3 多生产者多消费者问题
7.3.1 安全问题的产生
当上述案例变为多生产者、多消费者时,又会出现新的问题
- 线程的notify(),只唤醒第一个等待的线程,有可能重复唤醒同一种类型的线程(只唤醒生产者的某个线程,或只唤醒消费者的某个线程)
- 解决办法 : 全部唤醒 notifyAll()
- 被唤醒线程,已经进行过if判断,一旦醒来继续执行
- 线程被唤醒后,不能立刻就执行,再次判断标志位,利用循环
- while(标志位) 标志位是true,永远也出不去(以生产者为例)
代码改造:
/**
* 定义资源对象
* 成员 : 产生商品的计数器
* 标志位
*/
public class Resource {
private int count ;
private boolean flag ;
//消费者调用
public synchronized void getCount() {
//flag是false,消费完成,等待生产
while (!flag)
//无限等待
try{this.wait();}catch (Exception ex){}
System.out.println("消费第"+count);
//修改标志位,为消费完成
flag = false;
//唤醒对方线程
this.notifyAll();
}
//生产者调用
public synchronized void setCount() {
//flag是true,生产完成,等待消费
while (flag)
//无限等待
try{this.wait();}catch (Exception ex){}
count++;
System.out.println("生产第"+count+"个");
//修改标志位,为生产完成
flag = true;
//唤醒对方线程
this.notifyAll();
}
}
/**
* 生产者线程
* 资源对象中的变量++
*/
public class Produce implements Runnable{
private Resource r ;
public Produce(Resource r) {
this.r = r;
}
@Override
public void run() {
while (true) {
r.setCount();
}
}
}
/**
* 消费者线程
* 资源对象中的变量输出打印
*/
public class Customer implements Runnable{
private Resource r ;
public Customer(Resource r) {
this.r = r;
}
@Override
public void run() {
while (true) {
r.getCount();
}
}
}
public static void main(String[] args) {
Resource r = new Resource();
//接口实现类,生产的,消费的
Produce produce = new Produce(r);
Customer customer = new Customer(r);
//创建线程
new Thread(produce).start();
new Thread(produce).start();
new Thread(produce).start();
new Thread(produce).start();
new Thread(produce).start();
new Thread(produce).start();
new Thread(customer).start();
new Thread(customer).start();
new Thread(customer).start();
new Thread(customer).start();
new Thread(customer).start();
new Thread(customer).start();
}
7.4 线程方法sleep和wait的区别
- sleep在休眠的过程中,同步锁不会丢失 ,不释放
- wait()等待的时候,发布监视器的所属权, 释放锁。唤醒后要重新获取锁,才能执行。
Thread.sleep(time);
锁对象.wait()
7.5 生产者和消费者案例性能问题
wait()方法和notify()方法,本地方法调用OS的功能,和操作系统交互,JVM找OS,把线程停止。频繁等待与唤醒,导致JVM和OS交互的次数过多。
notifyAll()唤醒全部的线程,也浪费线程资源,为了一个线程,不得以唤醒了全部的线程。
7.6 Lock接口改进
Lock接口替换了同步synchronized,提供了更加灵活,性能更好的锁定操作
- Lock接口中方法 : newCondition() 方法的返回值是接口 : Condition
7.6.1 生产者消费者改进为Lock接口
- Condition接口 (线程的阻塞队列)
- 进入队列的线程,释放锁
- 出去队列的线程,再次的获取锁
- 接口的方法 : await() 线程释放锁,进入队列
- 接口的方法 : signal() 线程出去队列,再次获取锁
线程的阻塞队列,依赖Lock接口创建
/**
* 改进为高性能的Lock接口和线程的阻塞队列
*/
public class Resource {
private int count ;
private boolean flag ;
private Lock lock = new ReentrantLock();//Lock接口实现类对象
//Lock接口锁,创建出2个线程的阻塞队列
private Condition prod = lock.newCondition();//生产者线程阻塞队列
private Condition cust = lock.newCondition();//消费者线程阻塞队列
//消费者调用
public void getCount() {
lock.lock();//获取锁
//flag是false,消费完成,等待生产
while (!flag)
//无限等待,消费线程等待,执行到这里的线程,释放锁,进入到消费者的阻塞队列
try{cust.await();}catch (Exception ex){}
System.out.println("消费第"+count);
//修改标志位,为消费完成
flag = false;
//唤醒生产线程队列中的一个
prod.signal();
lock.unlock();//释放锁
}
//生产者调用
public void setCount() {
lock.lock();//获取锁
//flag是true,生产完成,等待消费
while (flag)
//无限等待,释放锁,进入到生产线程队列
try{prod.await();}catch (Exception ex){}
count++;
System.out.println("生产第"+count+"个");
//修改标志位,为生产完成
flag = true;
//唤醒消费者线程阻塞队列中年的一个
cust.signal();
lock.unlock();//释放锁
}
}
7.6.2 Lock锁的实现原理
使用技术不开源,技术的名称叫做轻量级锁
使用的是CAS锁 (Compare And Swap) 自旋锁
JDK限制 : 当竞争的线程大于等于10,或者单个线程自旋超过10次的时候,JDK强制CAS锁取消。升级为重量级锁 (OS锁定CPU和内存的通信总线)。
八、单例设计模式
要求 : 保证一个类的对象在内存中的唯一性
8.1 饿汉式
实现步骤
- 私有修饰构造方法
- 自己创建自己的对象
- 方法get,返回本类对象
/**
* - 私有修饰构造方法
* - 自己创建自己的对象
* - 方法get,返回本类对象
*/
public class Single {
private Single(){}
//饿汉式
private static final Single s = new Single(); // 自己创建自己的对象
// 方法get,返回本类对象
public static Single getInstance(){
return s;
}
}
8.2 懒汉式
实现步骤
- 私有修饰构造方法
- 创建本类的成员变量, 不new对象
- 方法get,返回本类对象
/**
* - 私有修饰构造方法
* - 创建本类的成员变量, 不new对象
* - 方法get,返回本类对象
*/
public class Single {
private Single(){}
//懒汉,对象的延迟加载
private static Single s = null;
public static Single getInstance(){
//判断变量s,是null就创建
if (s == null) {
s = new Single();
}
return s;
}
}
8.2.2 懒汉式的安全问题
一个线程判断完变量 s=null,还没有执行new对象,被另一个线程抢到CPU资源,同时有2个线程都进行判断变量,对象创建多次。因此需要加上同步代码块:
public static Single getInstance(){
synchronized (Single.class) {
//判断变量s,是null就创建
if (s == null) {
s = new Single();
}
}
return s;
}
性能问题 : 第一个线程获取锁,创建对象,返回对象。 第二个线程调用方法的时候,变量s已经有对象了,根本就不需要再进同步,不要再判断空,直接return才是最高效的。双重的if判断,提高效率 Double Check Lock。
最终的懒汉式代码如下:
/**
* - 私有修饰构造方法
* - 创建本类的成员变量, 不new对象
* - 方法get,返回本类对象
*/
public class Single {
private Single(){}
private static volatile Single s = null;
public static Single getInstance(){
//再次判断变量,提高效率
if(s == null) {
synchronized (Single.class) {
//判断变量s,是null就创建
if (s == null) {
s = new Single();
}
}
}
return s;
}
}
8.3 关键字volatile
成员变量修饰符,不能修饰其它内容
关键字作用 :
- 保证被修饰的变量,在线程中的可见性
- 防止指令重排序
- 单例模式,使用了该关键字,不使用关键字,可能线程会拿到一个尚未初始化完成的对象(半初始化)。
九、线程池ThreadPool
线程的缓冲池,目的就是提高效率。 new Thread().start()
,线程是内存中一个独立的方法栈区,JVM没有能力开辟内存空间,需要和OS交互。
JDK5开始内置线程池
9.1 Executors类
-
静态方法
static newFixedThreadPool(int 线程的个数)
- 方法的返回值是
ExecutorService
,Executors接口的实现类,管理池子里面的线程
- 方法的返回值是
-
ExecutorService接口的方法
- submit (Runnable r)提交线程执行的任务
9.2 Callable接口
实现多线程的程序 : 接口特点是有返回值,可以抛出异常 (Runnable没有)
抽象的方法只有一个 call()
启动线程,线程调用重写方法call()
- ExecutorService接口的方法
submit (Callable c)
提交线程执行的任务Future submit(Callable c)
方法提交线程任务后,方法有个返回值 Future接口类型- Future接口的
get()
方法,获取线程执行后的返回值结果
public class MyCall implements Callable<String> {
public String call() throws Exception{
return "返回字符串";
}
}
public static void main(String[] args) throws ExecutionException, InterruptedException {
//创建线程池,线程的个数是2个
ExecutorService es = Executors.newFixedThreadPool(2);
//线程池管理对象service,调用方法啊submit提交线程的任务
MyRunnable my = new MyRunnable();
//提交线程任务,使用Callable接口实现类
Future<String> future = es.submit(new MyCall());//返回接口类型 Future
//接口的方法get,获取线程的返回值
String str = future.get();
System.out.println("str = " + str);
}
9.3 ConcurrentHashMap
ConcurrentHashMap类本质上是Map集合,键值对的集合。使用方式和HashMap没有区别。
凡是对于此Map集合的操作,不去修改里面的元素,不会锁定。