多线程
目的
区分进程和线程的概念
进程：正在运行的一个程序QQ IDE 浏览器
系统会为这个进程分配独立的内存资源
线程：具体执行任务的最小单位
一个进程最少拥有一个线程（主线程 运行起来就执行的线程）
线程之间是共享内存资源的（进程申请的）
线程之间可以通信（数据传递，多数为主线程和子线程）
每一个线程都有自己的运行回路（生命周期）
1个进程中可以开启多条线程，每条线程可以并行（同时）执行不同的任务
为什么需要创建子线程
如果在主线程中存在有比较耗时的操作：下载视频 上传文件 数据处理
这些操作会阻塞主线程 ，后面的任务必须等这些任务执行完毕
之后才能执行，用户体验比较差
为了不阻塞主线程 需要将耗时的任务放在子线程中去处理
技术
1.如何创建一个线程 Thread Runnable
2.线程的同步 synchronized ReentrantLock
3.主线程和子线程之间使用接口回调数据
3.线程之间的通信：synchronized (wait notify notifyAll)
ReentrantLock lock;
Condition c = lock.newCondition();
await signal signalAll
技术实现
- 如何创建一个线程
1.创建一个继承Thread 实现run方法 方法里面就是具体需要执行的代码
class TestThread extends Thread{
@Override
public void run() {
String name = Thread.currentThread().getName();
for (int i = 0; i < 100; i++) {
System.out.println(name+":"+(i+1));
if (this != MyClass.tt2) {
if (i == 9) {
try {
MyClass.tt2.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
super.run();
}
}
创建该类的对象来调用start方法
将tt2对象静态化，实现共享
static TestThread tt2;
// main 方法里面执行的代码 是在主线程里面执行的
// 主线程的名称为main
String name = Thread.currentThread().getName();
System.out.println(name);
// 创建Thread的对象
TestThread tt = new TestThread();
// 设置线程的名称
tt.setName("子线程1");
// 开启任务
tt.start();
// for (int i = 0; i < 5; i++) {
// System.out.println("main:"+(i+1));
// }
tt2 = new TestThread();
// 设置线程的名称
tt2.setName("子线程2");
// 开启任务
tt2.start();
2.创建一个任务：创建一个类实现Runnable接口
class aThread extends Thread implements Runnable{
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println(Thread.currentThread().getName()+":"+(i+1));
}
}
}
aThread at = new aThread();
// 使用Thread操作这个任务
Thread t = new Thread(at);
t.setName("子线程1");
t.start();
Thread t2 = new Thread(at);
t2.setName("子线程2");
t2.start();
这个任务只做一次
Thread t = new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println(Thread.currentThread().getName()+":"+(i+1));
}
}
});
t.setName("子线程1");
t.start();
创建线程的同时 直接开线程任务
// 不需要操作线程对象本身
new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println(Thread.currentThread().getName()+":"+(i+1));
}
}
}).start();
使用Lambda表达式
// 阅读性差
new Thread(()->{
for (int i = 0; i < 100; i++) {
System.out.println(Thread.currentThread().getName()+":"+(i+1));
}
}).start();
-
线程安全
多个线程操作同一资源，线程无法确定自己什么时候被阻塞
容易导致数据错误
synchronized Lock 加锁解锁
synchronized 同步监听器 需要一把锁任何一个对象都有自己的一把锁
如果多个线程操作同一个代码块 并且需要同步
那么就只能操作同一把锁1.同步代码块
synchronized (监听器/对象/锁){}
2.同步方法 同步监听器是当前对象本身
必须确保多个对象调用的同步方法时操作的同一个对象
public synchronized void test()
本质上就是同步代码块等价于 synchronized(this){ test(); } wait notify notifyAll Lock ReentrantLock 可重入锁
火车站卖票
// 全国的买票系统就一个
// 重庆 上海
用于卖票的任务
class Ticket implements Runnable{
// 定义所有车票的数量
public static int nums = 100;
String name;
public Ticket(String name){
this.name = name;
}
static final Object obj = new Object();
static ReentrantLock lock = new ReentrantLock();
Condition condition = lock.newCondition();
@Override
public void run() {
for (int i = 1; i <= 100; i++) {
// 判断有没有票
lock.lock();
// synchronized (obj) {
if (nums > 0) {
System.out.println(name + "出票:" + i);
nums--;
try {
condition.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
} else {
break;
}
lock.unlock();
}
// }
}
}
Ticket ticket1 = new Ticket("重庆");
Thread t1 = new Thread(ticket1);
t1.start();
Ticket ticket2 = new Ticket("上海");
Thread t2 = new Thread(ticket2);
t2.start();
使用接口实现线程间数据回调
Person类
Agent类 线程里面
public class Agent extends Thread{
AgentInterface target;
@Override
public void run() {
System.out.println(Thread.currentThread().getName());
System.out.println("开始找房子");
System.out.println("---------");
System.out.println("房子找到了 即将返回数据");
target.callBack("房子在西南大学");
super.run();
}
public interface AgentInterface{
void callBack(String desc);
}
}
public class Person implements Agent.AgentInterface {
public void needHouse(){
Agent xw = new Agent();
xw.target = this ;
xw.start();
}
@Override
public void callBack(String desc) {
System.out.println("我是小王，接收到你的数据了："+desc);
}
}
在main函数中创建对象调用函数
Person xw = new Person();
xw.needHouse();
心得
主线程的使用注意:别将比较耗时的操作放到主线程中。
耗时操作会卡住主线程，严重影响UI的流畅度，给用户一种“卡”的坏体验
