Java多线程概念
进程(Process):
进程是程序的一次执行过程，是系统运行程序的基本单位，因此进程是动态的。系统运行一个程序即是一个进程从创建，运行到消亡的过程。简单来说，一个进程就是一个执行中的程序，它在计算机中一个指令接着一个指令地执行着，同时，每个进程还占有某些系统资源如CPU时间，内存空间，文件，文件，输入输出设备的使用权等等。换句话说，当程序在执行时，将会被操作系统载入内存中。
线程(Thread):
是具体执行任务的最小单位，线程是进程划分成的更小的运行单位。线程和进程最大的不同在于基本上各进程是独立的，而各线程则不一定，因为同一进程中的线程极有可能会相互影响。从另一角度来说，进程属于操作系统的范畴，主要是同一段时间内，可以同时执行一个以上的程序，而线程则是在同一程序内几乎同时执行一个以上的程序段。
线程之间共享内存资源（进程申请的 ），且线程之间可以进行通信，每一个线程都有自己的运行回路。
多线程：
多线程就是几乎同时执行多个线程。
一个线程的生命周期
线程生命周期
线程的状态
线程的状态
1. 初始(NEW)：新创建了一个线程对象，但还没有调用start()方法。
2. 运行(RUNNABLE)：Java线程中将就绪（ready）和运行中（running）两种状态笼统的称为“运行”。线程对象创建后，其他线程(比如main线程）调用了该对象的start()方法。该状态的线程位于可运行线程池中，等待被线程调度选中，获取CPU的使用权，此时处于就绪状态（ready）。就绪状态的线程在获得CPU时间片后变为运行中状态（running）。
3. 阻塞(BLOCKED)：表示线程阻塞于锁。
4. 等待(WAITING)：进入该状态的线程需要等待其他线程做出一些特定动作（通知或中断）。
5. 超时等待(TIMED_WAITING)：该状态不同于WAITING，它可以在指定的时间后自行返回。
6. 终止(TERMINATED)：表示该线程已经执行完毕。
为什么要创建一个子线程
如果在主线程存在有比较耗时的操作，例如：下载视频 上传文件， 这些操作会阻塞主线程 后面的任务必须等这些任务执行完，这样就会导致用户体验比较差。为了不阻塞主线程 ， 需要将耗时的任务放在子线程去处理。
如何创建一个子线程
1. 写一个类继承于Thread 实现run方法
| 序号 | 方法 | 描述 |
|---|---|---|
| 1 | public void start() | 使该线程开始执行；Java 虚拟机调用该线程的 run 方法。 |
| 2 | public void run() | 如果该线程是使用独立的 Runnable 运行对象构造的，则调用该 Runnable 对象的 run 方法；否则，该方法不执行任何操作并返回。 |
| 3 | public final void setName(String name) | 改变线程名称，使之与参数 name 相同。 |
| 4 | getName() | 获取线程名称 |
| 5 | public final void join(long millisec) | 等待该线程终止的时间最长为 millis 毫秒。 |
| 6 | public static void sleep(long millisec) | 在指定的毫秒数内让当前正在执行的线程休眠（暂停执行） |
| 7 | public static Thread currentThread() | 返回对当前正在执行的线程对象的引用。 |
public class MyClass {
static TestThread tt2;
public static void main(String[] args){
//main方法里面执行执行的代码是在主线程里面执行的
//主线程的名称是main
String name = Thread.currentThread().getName();
System.out.println(name);
// 创建TestThread对象
TestThread tt = new TestThread();
//设置线程的名称
tt.setName("子线程1");
// 开启任务
tt.start();
// 创建TestThread对象
tt2 = new TestThread();
//设置线程的名称
tt2.setName("子线程2");
// 开启任务
tt2.start();
}
}
class TestThread extends Thread {
//实现run方法
//方法里面就是需要具体执行的代码
@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();
}
}
2. 实现Runnable接口 实现run方法
- a.创建任务 创建类实现Runnable接口
- b.使用Thread为这个任务分配线程
- c.开启任务 start
- 创建一个类实现Runnable接口，使用Thread操作这个任务
public class MyClass {
public static void main(String[] args) {
//1.接口 抽象方法
//创建一个任务：创建一个类实现Runnable接口
GYLThread gt = new GYLThread();
//使用Thread操作这个任务
Thread t = new Thread(gt);
t.setName("子线程1");
t.start();
Thread t2 = new Thread(gt);
t2.setName("子线程2");
t2.start();
}
}
class GYLThread implements Runnable{
@Override
public void run() {
for (int i = 0;i < 100;i++){
System.out.println(Thread.currentThread().getName()+" "+(i+1));
}
}
}
- 这个任务只使用一次
//这个任务只使用 一次
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();
线程同步
为何要使用同步？
java允许多线程并发控制，当多个线程同时操作一个可共享的资源变量时（如数据的增删改查）， 将会导致数据不准确，相互之间产生冲突，因此加入同步锁以避免在该线程没有完成操作之前，被其他线程的调用， 从而保证了该变量的唯一性和准确性。
-
使⽤synchronized同步代码块
java的每个对象都有一个内置锁，即有synchronized关键字修饰的语句块， 被该关键字修饰的语句块会自动被加上内置锁，从而实现同步。
代码如：synchronized(监听器、对象、锁){
//需要加锁的代码
}
main方法：
Ticket ticket = new Ticket("重庆");
Thread t1 = new Thread(ticket);
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();
@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) {
test();
}
@Override
public void run() {
synchronized(this) {
test();
}
}
public synchronized void test(){
for (int i = 1;i <= 100;i++) {
//判断有没有票
if (num > 0) {
System.out.println(name + "出票：" + num);
num--;
}else{
break;
}
}
}
-
让两个线程交替执行
image.png
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.printStackTrance();
}
}else{
break;
}
}
}
-
使⽤ReentrantLock同步
//创建一个可重入的锁
static ReentrantLock lock = new ReentrantLock();
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();
}
}
Demo
Person.java
public class Person implements Agent.AgentInterface {
public void needHouse(){
Agent xw = new Agent();
xw.target = this;
xw.start();
}
@Override
public void callBack(String description) {
System.out.println("我是小王：接收到你的数据了"+description);
}
}
Agent.java
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 description);
}
}
main
public class Test {
public static void main(String[] args){
Person zs = new Person();
zs.needHouse();
}
}
心得体会
多线程这块的知识比较多，理解起来也需要花大量的时间来熟练，刚开始听确实不是那么理解，但是写多了就觉得没什么了，还是要多练习。
