并发:指两个或多个事件在同一个时间段内发生
并行:指两个或多个事件在同一时刻发生(同时发生)
进程:是指一个内存中运行的应用程序,每个进程都有一个独立的内存空间,一个应用程序可以同时运行多个进程;进程也是程序的一次执行过程,是系统运行程序的基本单位;系统运行一个程序即是一个进程从创建、运行到消亡的过程
线程:线程是进程中的一个执行单元,负责当前进程中程序的执行,一个进程中至少有一个线程,一个进程中是可以有多个线程的,这个应用程序可以称之为多线程程序;简而言之,一个程序运行后至少有一个进程,一个进程可以包含多个线程
单核心单线程cpu:cpu在多个线程之间做高速的切换轮流执行多个线程,效率低
4核心8线程:有8个线程可以同时执行,8个线程在多个任务之间做高速的切换,速度是单线程cpu的8倍
线程调度:
- 分时调度:所有线程轮流使用CPU的使用权,平均分配每个线程占用CPU的时间
- 抢占式调度:优先让优先级高的线程使用CPU,如果线程的优先级相同,那么会随机选择一个(线程随机性),Java使用的为抢占式调度
JVM执行main方法,main方法会进入到栈内存;JVM会找操作系统开辟一条main方法通向cpu的执行路径,cpu就可以通过这个路径来执行main方法;而这个路径有一个名字,叫main(主)线程
创建多线程:
-
第一种方式:创建Thread类的子类(继承Thread)
-
创建一个Thread类的子类
-
在子类中重写Thread类中的run方法,设置线程任务
-
创建子类对象,调用Thread类中的方法start方法,开启新的线程,执行run方法
- 多次启动一个线程是非法的,特别是当线程已经结束执行后,不能再重新启动
-
匿名内部类创建线程:
new Thread(){ @Override public void run(){ ......... }.start(); }
-
-
Thread类
- 构造方法:
- public Thread():分配一个新的线程对象
- public Thread(String name):分配一个指定名字的新的线程对象
- public Thread(Runnable target):分配一个带有指定目标新的线程对象
- public Thread(Runnable target,String name):分配一个带有指定目标新的线程对象并指定名字
- 常用方法:
- public String getName():获取当前线程名称
- public void start():导致此线程开始执行,java虚拟机调用此线程的run方法
- public void run():此线程要执行的任务在此处定义代码
- public static void sleep(long millis):使当前正在执行的线程以指定的毫秒数暂停
- 构造方法:
-
第二种方式:实现Runnable接口
-
创建一个Runnable接口的实现类
-
在实现类中重写Runnable接口的run方法,设置线程任务
-
创建一个Runnable接口的实现类对象
-
创建Thread类对象,构造方法中传递Runnable接口的实现类对象
-
调用Thread类中的start方法,开启新的线程执行run方法
-
RunnableImpl run = new RunnableImpl(); Thread t = new Thread(run); t.start();
-
匿名内部类创建线程:
Runnable r = new Runnable(){ @Override public void run(){ ......... }.start(); } new Thread(r).start()
-
好处:
- 避免了单继承的局限性
- 一个类只能继承一个类,类继承了Thread类就不能继承其他的类
- 实现了Runnable接口,还可以继承其他的类,实现其他的接口
- 增强了程序的扩展性,降低了程序的耦合性
- 实现Runnable接口的方式,把设置线程任务和开启新线程进行了分离(解耦)
- 实现类中,重写了run方法:用来设置线程任务
- 创建Thread类对象,调用start:用来开启新线程
- 避免了单继承的局限性
-
多线程访问共享的数据会产生线程安全问题
线程同步:
-
使用同步代码块:
synchronized(锁对象){ 可能会出现线程安全问题的代码 } 执行逻辑:3个线程一起抢夺cpu的执行权,谁抢到了谁执行run方法;t0抢到了cpu的执行权,执行run方法,遇到synchronized代码块,这时t0会检查synchronized代码块是否有锁对象,发现有,就会获取到锁对象,进入到同步中执行;t1抢到了cpu的执行权,执行run方法,遇到synchronized代码块,这时t1会检查synchronized代码块是否有锁对象,发现没有,t1就会进入到阻塞状态会一直等待t0线程归还锁对象;等到t0线程执行完同步中的代码,会把锁对象归还给同步代码块,t1才能获取到锁对象进入到同步中执行 同步保证了只能有一个线程在同步中执行共享数据,保证了安全;但程序频繁的判断锁,获取锁,释放锁,程序的效率会降低 1.通过代码块中的锁对象,可以让一个线程在同步代码块中执行 2.但是必须保证多个线程使用的锁对象是同一个 3.锁对象作用:把同步代码块锁住,只让一个线程在同步代码块中执行
-
使用同步方法:
修饰符 synchronized 返回值类型 方法名(参数列表){ 可能会出现线程安全问题的代码 }
执行逻辑:同步方法也会把方法内部的代码锁住,只让一个线程执行,同步方法的锁对象就是实现类对象new RunnableImpl();也就是this
3. 使用Lock锁
```java
//1.创建一个ReentrantLock对象
Lock l = new ReentrantLock();
l.lock();
........代码
l.unlock();
线程状态:
-
NEW:新建状态
-
RUNNABLE:运行状态
-
BLOCKED:阻塞状态
-
TERMINATED:死亡状态
-
WAITING:无限等待状态
-
TIMED_WAITING:休眠状态
-
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-X2MggtJX-1675664424646)(D:\Typora笔记\Java笔记\JavaSE\thread.jpg)]
-
/** *等待唤醒案例:线程通信 */ void wait():在其他线程调用此对象的notify方法或notifyAll()方法前,导致当前线程等待 void notify():唤醒在此对象监视器上等待的单个线程,会继续执行wait方法之后的代码 //创建锁对象,保证唯一 Object obj = new Object(); new Thread(){ @Override public void run(){ //保证等待和唤醒的线程只能有一个执行,需要使用同步技术 synchronized (obj){ //调用wait方法,放弃cpu的执行,进入到WAITING状态 try{ obj.wait(); }catch (InterruptedException e){ e.printStackTrace(); } } } }.start(); new Thread(){ @Override public void run(){ try{ Thread.sleep(5000); }catch (InterruptedException e){ e.printStackTrace(); } //保证等待和唤醒的线程只能有一个执行,需要使用同步技术 synchronized (obj){ //调用wait方法,放弃cpu的执行,进入到WAITING状态 try{ obj.notify(); }catch (InterruptedException e){ e.printStackTrace(); } } } }.start(); 注意事项:通知一个等待的线程,被通知的线程也不能立即恢复执行,因为它当初中断的地方是在同步块内,而此刻它已经不持有锁,所以需要再次尝试去获取锁,成功后才能在当初调用wait方法之后的地方恢复执行 进入到TimeWating(计时等待)有两种方式: 1.使用sleep(long m)方法,在毫秒值结束之后,线程睡醒进入到Runnable/Blocked状态 2.使用wait(long m)方法,wait方法如果在毫秒值结束之后,还没有被notify唤醒,就会自动醒来,线程睡醒进入到Runnable/Blocked状态 唤醒的方法: void notify() 唤醒在此对象监视器上等待的单个线程;如果有多个等待线程,随机唤醒一个 void notifyAll() 唤醒在此对象监视器上等待的所有线程
线程间通信:
多个线程并发执行时,在默认情况下cpu是随机切换线程的,当我们需要多个线程来共同完成一件任务,并且我们希望他们有规律的执行,那么多线程之间需要一些协调通信,以此来帮我们达到多线程共同操作一份数据
如何保证线程间通信有效利用资源:
多个线程在处理同一个资源,并且任务不同时,需要线程通信来帮助解决线程之间对同一个变量的使用或操作。就是多个线程在操作同一份数据时,避免对同一共享变量的争夺。也就是我们需要通过一定的手段使各个线程能有效的利用资源。而这种手段即--------等待唤醒机制
线程池:
就是一个容纳多个线程的容器,其中的线程可以反复使用,省去了频繁创建线程对象的操作,无需反复创建线程而消耗过多的资源
线程池的好处:
- 降低资源消耗。减少创建和销毁线程的次数,每个工作线程都可以被重复利用,可执行多个任务。
- 提高响应速度。当任务到达时,任务可以不需要等到线程创建就能立即执行
- 提高线程的可管理性。可以根据系统的承受能力,调整线程池中工作线程的数量,防止因为消耗过多的内存,而把服务器累趴(每个线程需要大约1MB内存,线程开的越多,消耗的内存也就越大,最后死机)
java.util.concurrent.Executors:线程池的工厂类,用来生成线程池
Executors类中的静态方法:
static ExecutorService newFixedThreadPool(int nThreads) 创建一个可重用固定线程数的线程池
参数:int nThreads:创建线程池中包含的线程数量
返回值:
ExecutorService接口,返回的是ExecutorService接口的实现类对象,可以使用ExecutorService接口接收(面向接口编程)
java.util.concurrent.ExecutorService:线程池接口
用来从线程池中获取线程,调用start方法,执行线程任务
submit(Runnable task)提交一个Runnable任务用于执行
关闭/销毁线程池的方法
void shutdown()
线程池会一直开启,使用完了线程,会自动把线程归还给线程池,线程可以继续使用
线程池的使用步骤:
1.使用线程池的工厂类Executors里边提供的静态方法newFixedThreadPool生产一个指定线程数量的线程池
ExecutorService es = Executors.newFixedThreadPool(2)
2.创建一个类,实现Runnable接口,重写run方法,设置线程任务
3.调用ExecutorService中的方法submit,传递线程任务(实现类),开启线程,执行run方法
es.submit(new RunnableImpl());
4.调用ExecutorService中的方法shutdown销毁线程池(不建议执行)
l生产一个指定线程数量的线程池
ExecutorService es = Executors.newFixedThreadPool(2)
2.创建一个类,实现Runnable接口,重写run方法,设置线程任务
3.调用ExecutorService中的方法submit,传递线程任务(实现类),开启线程,执行run方法
es.submit(new RunnableImpl());
4.调用ExecutorService中的方法shutdown销毁线程池(不建议执行)