目录
多线程
进程线程:
**进程:**正在运行的程序
是系统进行资源分配和调用的独立单位
每一个进程都有它自己的内存空间和系统资源
线程:
CPU调度和分派的基本单位;进程中执行运算的最小单位,可完成一个独立的顺序控制流程
**单线程:**一个进程如果只有一条执行路径,则称为单线程
多线程:
概念:
如果一个进程中同时运行了多个线程,用来完成不同的工作,则称之为“多线程”
多个线程交替占用CPU资源,而非真正的并行执行
好处:
- 充分利用CPU资源
- 简化编程模型
- 带来良好的用户体验
主线程:
Thread类
-
java提供 java.lang.Thread 类支持多线程编程
-
主线程:
- main()方法即为主线程入口
- 产生其他子线程的线程
- 必须最后完成执行,因为它执行各种关闭动作
public static void main(String args[]){ Thread t = Thread.currentThread(); System.ou.println("当前线程是:"+t.getName()); t.setName("MyJavaThread"); System.ou.println("当前线程名是:"+t.getName()); }
线程的创建和启动:
创建的两种方式:
- 继承java.lang.Thread类
- 实现java.lang.Runnable接口
步骤:定义线程----->创建线程对象----->启动线程----->终止线程
▶继承Thread类创建线程
- 定义MyThread类继承Thread类
- 在MyThread类中重写run()方法,编写线程执行体
- 创建线程对象
- 调用start()方法启动线程
public class MyThread extends Thread{
//重写run()方法
public void run(){
for(int i=1;i<100;i++){
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}
public static void main(String[] args) {
MyThread thread = new MyThread();
thread.start(); //启动线程(就绪状态)
//static Thread currentThread():返回当前正在执行的线程对象的引用
//可以知道当前线程:
System.out.println(Thread.currentThread().getName()); //main
}
-
run()方法是用来封装被线程执行的代码
-
多个线程交替执行,并不是真正的“并行”
-
线程每次执行时长由分配的CPU时间长度决定
run()和start()的区别:
run():封装线程执行的代码,直接调用,相当于普通方法的调用
start():启动线程,然后由JVM调用此线程的run()方法
设置和获取线程名称:
Thread类中设置和获取线程名称方法:
//void setName(String name):将线程的名称更改为等于参数name.要在MyThread类中创建有无参构造方法
//无参构造方法
MyThread my1 =new MyThread();
MyThread my2 =new MyThread();
my1.setName("哇哈哈");
my2.setName("笑嘻嘻");
//有参构造方法 【super继承父类的name方法】
MyThread my1 =new MyThread("哇哈哈");
MyThread my2 =new MyThread("笑嘻嘻");
//String getName():返回此线程的名称
▶实现Runnable接口创建线程
- 定义MyRunnable类实现Runnable接口
- 在MyRunnable类中实现run()方法,编写线程执行体
- 创建线程对象,把MyRunnable对象作为构造方法的参数。
- 调用start()方法启动线程
public class MyRunnable implements Runnable{
public void run(){
for(int i=1;i<100;i++){
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}
public static void main(String[] args) {
MyRunnable myRunnable = new MyRunnable();
Thread myThread1 = new Thread(myRunnable);
Thread myThread2 = new Thread(myRunnable);
//启动线程
thread1.start();
thread2.start();
}
▶实现Callable接口创建线程
首先new 一个我的类实现实例化,然后将我生成的实例对象注册进入到FutureTask类中,然后将FutureTask类的实例注册进入Thread中运行。
最后可以采用FutureTask中的get() 方法获取自定义线程的返回值。
import java.util.concurrent.Callable;
public class MyCallable implements Callable<String> { //可以用泛型Callable<V>
@Override
public String call() throws Exception {
for(int i = 0; i<10; i++){
System.out.println(Thread.currentThread().getName()+":"+i);
}
return "这是我的返回值";
}
}
public static void main(String[] args) throws Exception {
MyCallable mc = new MyCallable();
//线程1
FutureTask ft1 = new FutureTask(mc);
Thread thread1 = new Thread(ft1);
thread1.start();
//线程2
FutureTask ft2 = new FutureTask(mc);
Thread thread2 = new Thread(ft2);
thread2.start();
Object s = ft2.get();
System.out.println(s);
}
三种方式的比较:
继承Thread类:编写简单,可直接操作线程;适用于单继承
实现Runnable接口:避免单继承局限性;便于共享资源 :把线程和程序的代码、数据有效分离,体现面向对象的设计思想(推荐使用)
实现Callable接口: FutureTask实现了Runnable接口和Future接口 ;call方法可以抛出异常;FutureTask中的get()方法获取自定义线程的返回值.
线程的状态:
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UjxZjpu0-1660047360051)(C:\Users\Lenovo\AppData\Roaming\Typora\typora-user-images\1659491008324.png)]
新建 就绪 sleep阻塞 运行 死亡
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-C2Wo7XP4-1660047360053)(C:\Users\Lenovo\AppData\Roaming\Typora\typora-user-images\1660015473572.png)]
线程的调度:
线程调度指按照特定机制为多个线程分配CPU的使用权
- 分时调度模型:所有线程轮流使用CPU的使用权,平均分配每个线程占用CPU的时间片
- java使用 抢占式调度模型:优先让优先级高的线程使用CPU,如果线程的优先级相同,那么随机选一个。优先级高的获取的CPU时间相对多些
方 法 | 说 明 |
---|---|
void setPriority(int newPriority) | 更改线程的优先级 |
static void sleep(long millis) | 在指定的毫秒数内让当前正在执行的线程休眠 |
void join() | 等待该线程终止 |
static void yield() | 暂停当前正在执行的线程对象,并执行其他线程 |
void interrupt() | 中断线程 |
boolean isAlive() | 测试线程是否处于活动状态 |
线程优先级:
- 线程优先级由1~10表示,1最低,默认优先级为5
- 优先级高的线程获得CPU资源的概率较大
public static void main(String[] args) {
//创建线程对象并指定线程名
Thread t1 = new Thread(new MyThread(),"线程A");
Thread t2 = new Thread(new MyThread(),"线程B");
t1.setPriority(Thread.MAX_PRIORITY); //最高级优先级:10
t2.setPriority(Thread.MIN_PRIORITY); //最低优先级:1
//默认是5
//省略代码……
}
设置和获取优先级的方法:
- public final int getPriority():返回此线程的优先级
- public final void setPriority(int newPriority):更改此线程的优先级
线程控制----
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XuCOJE32-1660047360054)(C:\Users\Lenovo\AppData\Roaming\Typora\typora-user-images\1660014030697.png)]
线程休眠sleep:
-
让线程暂时睡眠指定时长,线程进入阻塞状态
-
睡眠时间过后线程会再进入可运行状态
public static void sleep(long millis);
- millis为休眠时长,以毫秒为单位
- 调用sleep()方法需处理InterruptedException异常
public class Wait {
public static void bySec(long s) {
for (int i = 0; i < s; i++) {
System.out.println(i + 1 + "秒");
try {
Thread.sleep(1000); //线程休眠一秒
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
线程的强制运行join:
强制执行当前线程,join写在哪个线程,就阻塞谁
public final void join()
public final void join(long mills)
public final void join(long mills,int nanos)
示例:
public static void main(String[] args) {
Thread temp = new Thread(new MyThread());
temp.start();
for(int i=0;i<20;i++){
if(i==5){
try {
temp.join(); //阻塞主线程,子线程强制执行
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(Thread.currentThread().getName()+"运行:"+i);
}
//省略代码…
}
线程的礼让yield:
-
暂停当前线程,允许其他具有相同优先级的线程获得运行机会
-
该线程处于就绪状态,不转为阻塞状态
public static void yield()
只是提供一种可能,但是不能保证一定会实现礼让
public class MyThread implements Runnable{
public void run(){
for(int i=0;i<5;i++){
System.out.println(Thread.currentThread().getName()+"正在运行:"+i);
if(i==3){
System.out.print("线程礼让:");
Thread.yield();
}
}
}
}
join()方法和yield()方法的区别是:
同步方法:
- 使用synchronized修饰的方法控制对类成员变量的访问
- synchronized就是为当前的线程声明一把锁
访问修饰符 synchronized 返回类型 方法名(参数列表){……}
synchronized 访问修饰符 返回类型 方法名(参数列表){……}
同步代码块:
-
使用synchronized关键字修饰的代码块
synchronized(syncObject任意对象就是一把锁){ //需要同步的代码 }
-
syncObject为需同步的对象,通常用this
-
效果与同步方法相同
public void run() { while (true) { synchronized (this) { //同步代码块 // 省略修改数据的代码...... // 省略显示信息的代码...... } } }
-
代码解析:
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZBN9yMJ4-1660047360055)(C:\Users\Lenovo\AppData\Roaming\Typora\typora-user-images\1660022546695.png)]
- 好处:解决了多线程的数据安全
- 弊端:当线程很多时:因为每个线程会去判断同步上的锁,耗费资源,降低了程序的运行效率
多个并发线程访问同一资源的同步代码块时:
- 同一时刻只能有一个线程进入synchronized(this)同步代码块
- 当一个线程访问一个synchronized(this)同步代码块时,其他synchronized(this)同步代码块同样被锁定
- 当一个线程访问一个synchronized(this)同步代码块时,其他线程可以访问该资源的非synchronized(this)同步代码
线程安全的类型:
one:
ArrayList为非线程安全的类型
-
查看ArrayList类的add()方法定义
public boolean add(E e) { ensureCapacityInternal(size + 1); //集合扩容 ,确保能新增数据 elementData[size++] = e; //在新增位置存放数据 return true; }
-
ArrayList类的add()方法为非同步方法
-
当多个线程向同一个ArrayList对象添加数据时,可能出现数据不一致问题
方法是否同步 | 效率比较 | 适合场景 | |
---|---|---|---|
线程安全 | 是 | 低 | 多线程并发共享资源 |
非线程安全 | 否 | 高 | 单线程 |
常见类型对比:
Hashtable && HashMap
-
Hashtable
- 继承关系
- 实现了Map接口,Hashtable继承Dictionary类
- 线程安全,效率较低
- 键和值都不允许为null
- 继承关系
-
HashMap
- 继承关系
- 实现了Map接口,继承AbstractMap类
- 非线程安全,效率较高
- 键和值都允许为null
- 继承关系
StringBuffer&& StringBuilder
- 前者线程安全,后者非线程安全
------------- | ------------ | ---------------------- |
| 线程安全 | 是 | 低 | 多线程并发共享资源 |
| 非线程安全 | 否 | 高 | 单线程 |
常见类型对比:
Hashtable && HashMap
-
Hashtable
- 继承关系
- 实现了Map接口,Hashtable继承Dictionary类
- 线程安全,效率较低
- 键和值都不允许为null
- 继承关系
-
HashMap
- 继承关系
- 实现了Map接口,继承AbstractMap类
- 非线程安全,效率较高
- 键和值都允许为null
- 继承关系
StringBuffer&& StringBuilder
- 前者线程安全,后者非线程安全