心得体会
- 今天主要学习了多线程。多线程的知识点还挺更多的，但是如果将知识模块细化，就不会太困难。中午的时候我花了点时间复习了一下上午的内容，发现下午在设计到上午的只知识点时没有感到很迷茫，有些问题能够回答出来。但是下午的线程安全知识点让我挺费脑筋的。
今日知识点
-
1.进程和线程
-
2.线程的生命周期
-
3.创建子线程的原因
-
4.创建线程的方法
-
5.线程安全
-
6.线程入门小demo
1.进程和线程
-
进程与线程的定义
进程:
是一个正在执行中的程序，每一个进程执行都有一个执行顺序，该顺序是一个执行路径，或者叫一个控制单元,系统会为这个进程发配独立的内存资源。
例如：正在运行的 QQ、IDE、浏览器就是进程
线 程:
具体执行任务的最小单位 .就是进程中的一个独立控制单元，线程在控制着进程的执行。一个进程中至少有一个进程。
-
进程与线程的联系
| 序号 | 进程与线程的联系 |
|---|---|
| （1） | 一个进程最少拥有一个线程--主线程--- 运行起来就执行的线程 |
| （2） | 线程之间是共享内存资源的（这个内存资源是由进程申请的） |
| （3） | 线程之间可以通信（进行数据传递：多数为主线程和子线程） |
| （4） | 每一个线程都有自己的运行回路 |
2.线程的生命周期
| 线程的生命周期 | 定义 |
|---|---|
新建(NEW ) |
线程刚被创建好，从新建一个线程对象到程序start() 这个线程之间的状态，都是新建状态 |
就绪 (RUNNABLE） |
线程对象调用start()方法后，就处于就绪状态，等到JVM里的线程调度器的调度，只要抢到时间片就可以运行这个线程 |
运行（RUNNING） |
就绪状态下的线程在获取CPU资源后就可以执行run(),此时的线程便处于运行状态，运行状态的线程可变为就绪、阻塞及死亡三种状态 |
等待/阻塞/睡眠（BLOCKED） |
在一个线程执行了sleep（睡眠）、wait(等待）等方法后会失去所占有的资源，从而进入阻塞状态，在睡眠结束后可重新进入就绪状态 |
终止(TERMINATED) |
run（）方法完成后或发生其他终止条件时就会切换到终止状态 |
图例：
DJ9SFG5YXY6_)~QV}DW2_2N.png
3.创建子线程的原因
- 如果在主线程中存在有比较耗时的操作（例如：下载视频、上传文件 数据处理）
这些操作会阻塞主线程，后面的任务必须等这些任务执行完毕之后才能执行，用户体验比较差， 为了不阻塞主线程，需要将耗时的任务放在子线程去处理
4.创建线程的方法
-
创建线程的第一种方法---继承Thread类实现run方法
步骤：
① 定义类继承Thread;
② 复写Thread类中的run方法；（目的：将自定义代码存储在run方法，让线程运行）
③调用线程的start方法：(该方法有两步：启动线程，调用run方法)
public class Myclass {
public static void main(String[] args){
// main方法里面执性的代码 是在主线程里面执行的
String name=Thread.currentThread().getName();//创建一个对象，获取当前线程的名称赋给该对象
System.out.println(name);//打印线程的名称
//创建第一个线程
TestThread tt=new TestThread(); //创建Thread的对象
tt.setName("子线程1"); //设置线程的名称
tt.start();// //开启任务
//创建第二个线程
TestThread tt2=new TestThread();
tt2.setName("子线程2");
tt2.start();
}
}
// 定义一个类继承Thread
class TestThread extends Thread{
//复写Thread类中的run方法，方法里面具体需要执行的代码
@Override
public void run() {
String name=Thread.currentThread().getName();//创建了一个对象，获取了线程的名字赋给name
for(int i=0;i<100;i++){
System.out.println(name+":"+(i+1));
}
super.run();
}
}
20190818_161717.gif
试思考：如果main函数里面再加一个
tt.start();,结果会如何？
TestThread tt=new TestThread(); //创建Thread的对象
tt.setName("子线程1"); //设置线程的名称
tt.start();// //开启任务
tt.start();
回答：会出错，因为：对同一个线程不能同时开启
进阶小demo：
将上诉demo进行完善，实现当子线程1执行到10后，子线程1就被阻塞，然后开始执行线程2直至线程2结束，即线程2执行到100，然后才执行线程1
public class Myclass {
static TestThread tt2;
public static void main(String[] args) {
// main方法里面执性的代码 是在主线程里面执行的
String name = Thread.currentThread().getName();
System.out.println(name);
//创建Thread的对象
TestThread tt = new TestThread();
//设置线程的名称
tt.setName("子线程1");
//开启任务
tt.start();//只有这一句话耽误了一点时间
tt2 = new TestThread();
//设置线程的名称
tt2.setName("子线程2");
//开启任务
tt2.start();
}
}
class TestThread extends Thread {
//实现run方法
//方法里面具体需要执行的代码
@Override
public void run() {
String name = Thread.currentThread().getName();//创建了一个对象，获取了线程的名字赋给name
// System.out.println(name);
for (int i = 1; i < 101; i++) {
System.out.println(name + ":" + (i ));
if (this != Myclass.tt2) {//判断是否是子线程1
if (i == 10) {
try {
Myclass.tt2.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
super.run();
}
}
L2@A}}Z~8)JO9}7RK_3@E_T.png
上面一段demo中所用到的方法如下：
| 方法 | 作用 |
|---|---|
join() |
让当前这个线程阻塞 等join()的线程执行完毕再执行 |
setName() |
设置线程名称 |
getName() |
获取线程名称 |
currentTHread() |
获取当前运行的线程对象 |
-
创建线程的第二种方式：实现Runnable接口
注意事项： 接口应该由那些打算通过某一线程执行其实例的类来实现。类必须定义一个称为run 的无参方法。
步骤：
① 创建任务： 创建类实现Runnable接口
② 使用Thread 为这个任务分配线程
③ 开启任务Start()
使用方式1---创建一个类实现Runnable接口，使用Thread来操作这个任务
public class Myclass {
public static void main(String[] args) {
PXDThread pt=new PXDThread();//创建类的对象
//使用Thread操作这个任务
Thread t=new Thread(pt);
t.setName("子线程1");
t.start();
Thread t2=new Thread(pt);
t2.setName("子线程2");
t2.start();
}
}
class PXDThread implements Runnable{//创建了一个PXDThread类并实现Runnable接口
public void run() {
for(int i=0;i<=100;i++) {
System.out.println(Thread.currentThread().getName()+" :"+i);
}
}
}
（在main函数里）
使用方式2---这个任务只需要使用一次
public class Myclass {
public static void main(String[] args) {
Thread t=new Thread(new Runnable() {
@Override
public void run() {
for(int i=0;i<=100;i++) {
System.out.println(Thread.currentThread().getName()+": "+i);
}
}
});
t.setName("子线程1");
t.start();
Thread t2=new Thread(new Runnable() {
@Override
public void run() {
for(int i=0;i<=100;i++) {
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
});
t2.setName("子线程2");
t2.start();
}
}
使用方式3---创建线程的同时 直接开启线程任务，不需操作线程对象本身
new Thread(new Runnable() {
@Override
public void run() {
for(int i=0;i<=100;i++) {
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}).start();
**使用方式4--使用Lammbda表达式（不建议：阅读性太差）
new Thread(()->{
for(int i=0;i<=100;i++){
System.out.println(Thread.currentThread().getName()+":"+i);
}
}).start();
5.线程安全
- 多个线程操作同一个资源，线程无法确定自己什么时候被阻塞，容易导致数据错误
- 要编写
线程安全的代码，其核心在于要对状态访问操作进行管理，特别是对共享的和可变的状态的访问。一个对象是否需要是线程安全的，取决于它是否被多个线程访问。要使得对象是线程安全的，需要采用同步机制来协同对象可变状态的访问。当多个线程访问某个状态变量并且其中一个线程执行写入操作时，必须采用同步机制来协同这些线程对变量的访问。
-
同步代码块的两种方式
我们以卖火车票为例：
image.png
首先：我们来看一个小例子：
public class Myclass {
public static void main(String[] args) {
Ticket ticket=new Ticket("重庆");
Thread t1=new Thread(ticket);
t1.start();
Ticket ticket1=new Ticket("上海");
Thread t2=new Thread(ticket1);
t2.start();
}
}
//用于买票的任务(共享-》静态）
class Ticket implements Runnable {
//定义所有车票的数量
public static int num = 100;
String name;
public Ticket(String name) {
this.name = name;
}
@Override
public void run() {
for (int i = 0; i <= 100; i++) {
System.out.println(name + "出票：" +i);
}
}
}
得到的结果是：上海出票100，重庆出票100，并没有达到 重庆和上海共用100票的目的
-
同步代码块的第一种方式---synchronized（参数就是一个监听器）
synchronized(监听器/对象/对象的一把锁）{
//需要同步的代码
}
public class Myclass {
public static void main(String[] args) {
Ticket ticket=new Ticket("重庆");
Thread t1=new Thread(ticket);
t1.start();
Ticket ticket1=new Ticket("上海");
Thread t2=new Thread(ticket1);
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();
@Override
public void run() {
for (int i = 0; i <= 100; i++) {
synchronized (obj) {
if (num > 0) {
System.out.println(name + "出票：" + num);
num--;
try {
//当前线程等待
obj.notify();
obj.wait();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
//通知其他线程执行
}
} else {
break;
}
}
}
}
}
-
同步代码块的第二种方式---ReentrantLock
public class Myclass {
public static void main(String[] args) {
Ticket ticket=new Ticket("重庆");
Thread t1=new Thread(ticket);
t1.start();
Ticket ticket1=new Ticket("上海");
Thread t2=new Thread(ticket1);
t2.start();
}
}
class Ticket implements Runnable {
//定义所有车票的数量
public static int num = 100;
String name;
public Ticket(String name) {
this.name = name;
}
static ReentrantLock lock=new ReentrantLock();
@Override
public void run() {
for (int i = 0; i <= 100; i++) {
lock. lock();//加锁
if (num > 0) {
System.out.println(name + "出票：" + num);
num--;
} else {
break;
}
lock.unlock();//解锁
}
}
}
20190818_210342.gif
-
6.线程入门小demo
image.png
public class Person implements Agent.AgentInterface {//实现了Agent.AgentInterface接口
public void needHouse(){
Agent xw=new Agent();
xw.target=this;//表明吧对象返回给谁
xw.start();
}
@Override
public void callBack(String desc) {
System.out.println("我是小王，接收到你的数据了："+desc);
}
}
//1.继承Thread,重写run方法
public class Agent extends Thread{
AgentInterface target;
@Override
public void run() {
System.out.println(Thread.currentThread());
System.out.println("开始找房子");
System.out.println("----------");
System.out.println("房子找到了");
target.callBack("房子在西南大学");
super.run();
}
public interface AgentInterface{
void callBack(String desc);//把找到的房源信息返回
}
}
public class Myclass {
public static void main(String[] args) {
Person zs = new Person();
zs.needHouse();
}
}
image.png