知识点
- 进程：正在运行的某个程序 如：QQ 浏览器
系统会为这个进程分配独立的内存资源 - 线程：具体执行任务的最小单位
一个进程最少拥有一个线程(主线程 运行起来就执行的线程)
线程之间是共享一片内存空间(进程申请)
线程之间可以通信 (数据传递：多数为主线程和子线程)
每一个线程都有自己的运行回路(生命周期) - 线程的生命周期 状态
New：新建 线程刚被创建
RUNNABLE：就绪状态(准备好了，随时可以运行)只要抢到时间片就可以运行
BLOCKED：阻塞状态 (时间片结束 sleep wait)
WAITING：等待 wait
TIMED_WAITING
TERMINATED - 为什么需要创建一个子线程
如果在主线程中存在比较耗时的操作 如：下载视频，上传文件，数据处理
这些操作会阻塞主线程，后面的任务必须等这些任务执行完毕，之后才能执行，用户体验比较差
为了不阻塞主线程，需要将耗时的任务放在子线程中去处理 -
线程阻塞的原理
2M``N0O_9774F1D0TJ)Z@X6.png
内容梗概
-1. 如何创建一个(子)线程
-2.线程的同步
-3.主线程和子线程之间使用数据回调
-4.两个线程交替执行
-5.线程间的通信
主要内容
-1.如何创建一个(子)线程
- 写一个类继承于Thread,实现run方法
public class MyClass{
static TestThread1 tt2;
public static void main(String[] args){
// 创建Thread的对象
TestThread1 tt=new TestThread1();
// 设置线程的名称
tt.setName("子线程1");
// 开启任务
tt.start();
}
}
class TestThread1 extends Thread{
//实现run方法
@Override
public void run() {
//run方法里就是具体需要执行的代码
String name=Thread.currentThread().getName();
for (int i = 1; i <= 100; i++) {
System.out.println(name+":"+i);
}
super.run();
}
}
注：不能同时开启同一个线程，会出错
TestThread1 tt=new TestThread1();
tt.setName("子线程1");
tt.start();
TestThread1 tt2;
tt2=new TestThread1();
tt2.setName("子线程2");
tt2.start();
- 实现Runnable接口,实现run方法
(1)创建任务：创建类实现Runnable接口
(2)使用Thread,为这个任务分配线程
(3)开启任务,start()
有四种使用方法，先创建一个类
class ZRThread implements Runnable{
@Override
public void run() {
for (int i = 1; i< 100; i++) {
System.out.println(Thread.currentThread().getName()+": "+i);
}
}
}
第一种方法：
//步骤1：创建一个任务：创建一个类实现Runnable接口
ZRThread zt=new ZRThread();
//步骤2：使用Thread操作这个任务
Thread t=new Thread(zt);
t.setName("子线程1");
t.start();
Thread t2=new Thread(zt);
t2.setName("子线程2");
t2.start();
第二种方法：
//这个任务只需使用一次
Thread t=new Thread(new Runnable() {
@Override
public void run() {
for (int i = 1; i< 100; i++) {
System.out.println(Thread.currentThread().getName()+": "+i);
}
}
});
t.setName("子线程1");
t.start();
第三种方法：
//创建线程的同时 直接开启线程
//不需要操作线程对象本身
new Thread(new Runnable() {
@Override
public void run() {
for (int i = 1; i< 100; i++) {
System.out.println(Thread.currentThread().getName()+": "+i);
}
}
}).start();
第四种方法：
//使用Lambda表达式，但阅读性太差
new Thread(()->{
for (int i = 1; i< 100; i++) {
System.out.println(Thread.currentThread().getName()+": "+i);
}
}).start();
-2.线程的同步
- 线程安全
多个线程操作同一个资源，线程无法确定自己什么时候被阻塞，容易导致数据错误
- 同步代码块
synchronized (监听器/对象/锁){
需要同步的代码
}
public class MyClass {
public static void main(String[] args){
Ticket ticketCQ=new Ticket("重庆");
Thread t1=new Thread(ticketCQ);
t1.start();
}
}
class Ticket implements Runnable{
//定义所有车票的数量
public static int num=100;
String name;
public Ticket(String name){
this.name=name;
}
// static实现同步(代码块)
static final Object obj=new Object();
@Override
public void run() {
for (int i = 1; i <= 100; i++) {
synchronized (obj) {
//需要同步的代码
//判断有没有票
if (num > 0) {
System.out.println(name + "出票： " + num);
num--;
} else {
break;
}
}
}
}
}
- 同步方法 同步监听器是同一个对象
必须确保对象调用的同步操作时操作的统一对象
public synchronized void test() {
}
本质都是同步代码块
等价于
synchronized (this){
}
class Ticket implements Runnable {
public static int num = 100;
String name;
public Ticket(String name) {
this.name = name;
}
static final Object obj = new Object();
@Override
public void run() {
test();
}
public synchronized void test() {
for (int i = 1; i <= 100; i++) {
//需要同步的代码
//判断有没有票
if (num > 0) {
System.out.println(name + "出票： " + num);
num--;
} else {
break;
}
}
}
}
-3.主线程和子线程之间使用数据回调
public class MyClass {
public static void main(String[] args){
Person zs=new Person();
zs.needHouse();
}
}
class ZRThread implements Runnable{
@Override
public void run() {
for (int i = 1; i< 100; i++) {
System.out.println(Thread.currentThread().getName()+": "+i);
}
}
}
分别定义两个类，在主函数中实现回调
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);
}
}
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);
}
}
-4.两个线程交替执行
public class MyClass {
public static void main(String[] args){
Ticket ticketCQ=new Ticket("重庆");
Thread t1=new Thread(ticketCQ);
t1.start();
Ticket ticketSH=new Ticket("上海");
Thread t2=new Thread(ticketSH);
t2.start();
}
}
class Ticket implements Runnable{
public static int num=100;
String name;
public Ticket(String name){
this.name=name;
}
static final Object obj=new Object();
static ReentrantLock lock=new ReentrantLock();
@Override
public void run() {
for (int i = 1; i <= 100; i++) {
synchronized (obj) {
//需要同步的代码
//判断有没有票
if (num > 0) {
System.out.println(name + "出票： " + num);
num--;
try {
//通知其他线程执行
obj.notify();
//当前线程等待
obj.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
} else {
break;
}
}
}
}
}
-5.线程间的通信
-使用ReentrantLock同步
class Ticket implements Runnable{
//定义所有车票的数量
public static int num=100;
String name;
public Ticket(String name){
this.name=name;
}
// static实现同步(代码块)
//创建一个可重入的锁
static ReentrantLock lock=new ReentrantLock();
@Override
public void run() {
for (int i = 1; i <= 100; i++) {
//加锁
lock.lock();
//需要同步的代码
//判断有没有票
if (num > 0) {
System.out.println(name + "出票： " + num);
num--;
} else {
break;
}
//解锁
lock.unlock();
}
}
}
