线程的基础

文章目录

线程的介绍：
创建线程的三种方式：
- 一、继承Thread
- 二、实现Runnable接口
- 三、实现Callable接口
线程的优先级：
多线程：
线程终止：
线程常用方法：
用户线程和守护线程
线程的生命周期：
Synchronized
线程死锁
释放锁的操作
不会释放锁的操作：

线程的介绍：

在这里插入图片描述

1. 什么是程序：

在这里插入图片描述
2. 什么是进程：

3. 什么是线程：

4. 线程的相关概念：

并发和并行也可以同时存在

public class CpuNum {public static void main(String[] args) {Runtime runtime = Runtime.getRuntime();//获取当前电脑的cpu数量/核心数int cpuNums = runtime.availableProcessors();System.out.println("当前有cpu 个数=" + cpuNums);}
}

创建线程的三种方式：

在这里插入图片描述
还有一种是实现Callable接口。

一、继承Thread

在这里插入图片描述

** 当我们运行java程序的时候，就开启了一个线程（主线程（main线程）），只有线程上所有的线程结束，我们的线程才会结束**
真正实现多线程的效果，是start0(), 而不是 run

public class Thread01 {public static void main(String[] args) throws InterruptedException {//创建Cat对象，可以当做线程使用Cat cat = new Cat();//读源码/*(1)start方法public synchronized void start() {start0();}(2)start0方法//start0() 是本地方法，是JVM调用, 底层是c/c++实现//真正实现多线程的效果， 是start0(), 而不是 runprivate native void start0();*/cat.start();//启动线程-> 最终会执行cat的run方法//cat.run();//因为直接调用的run方法就是一个普通的方法, 没有真正的启动一个线程，主线程就会把run方法执行完毕，才向下执行//说明: 当main线程启动一个子线程 Thread-0, 主线程不会阻塞, 会继续执行//这时 主线程和子线程是交替执行..System.out.println("主线程继续执行" + Thread.currentThread().getName());//名字mainfor(int i = 0; i < 60; i++) {System.out.println("主线程 i=" + i);//让主线程休眠Thread.sleep(1000);}}
}//说明
//1. 当一个类继承了 Thread 类， 该类就可以当做线程使用
//2. 我们会重写 run方法，写上自己的业务代码
//3. Thread 类的run 方法是 实现了 Runnable 接口的run方法
/*@Overridepublic void run() {if (target != null) {target.run();}}*/class Cat extends Thread {int times = 0;@Overridepublic void run() {//重写run方法，写上自己的业务逻辑while (true) {//该线程每隔1秒。在控制台输出 “喵喵, 我是小猫咪”System.out.println("喵喵, 我是小猫咪" + (++times) + " 线程名=" + Thread.currentThread().getName());//让该线程休眠1秒 ctrl+alt+ttry {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}if(times == 80) {break;//当times 到80, 退出while, 这时线程也就退出..}}}
}

二、实现Runnable接口

在这里插入图片描述

public class Thread02 {public static void main(String[] args) {Dog dog = new Dog();//dog.start(); 这里不能调用start//创建了Thread对象，把 dog对象(实现Runnable),放入ThreadThread thread = new Thread(dog);thread.start();//        Tiger tiger = new Tiger();//实现了 Runnable
//        ThreadProxy threadProxy = new ThreadProxy(tiger);
//        threadProxy.start();}
}class Animal {
}class Tiger extends Animal implements Runnable {@Overridepublic void run() {System.out.println("老虎嗷嗷叫....");}
}//线程代理类 , 模拟了一个极简的Thread类
class ThreadProxy implements Runnable {//你可以把Proxy类当做 ThreadProxyprivate Runnable target = null;//属性，类型是 Runnable@Overridepublic void run() {if (target != null) {target.run();//动态绑定（运行类型Tiger）}}public ThreadProxy(Runnable target) {this.target = target;}public void start() {start0();//这个方法时真正实现多线程方法}public void start0() {run();}
}class Dog implements Runnable { //通过实现Runnable接口，开发线程int count = 0;@Overridepublic void run() { //普通方法while (true) {System.out.println("小狗汪汪叫..hi" + (++count) + Thread.currentThread().getName());//休眠1秒try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}if (count == 10) {break;}}}
}

三、实现Callable接口

callable是实现线程的一种处理方式，它的优点就是具有返回值，还可以有异常的抛出，并且在源码中可以看出在futuretask中对源码进行的处理。

理一遍callable的处理流程：
- 1）创建callable的实例化对象
- 2）把callable的实例化对象作为参数传入FutureTask对象中
- 3）把FutureTask作为参数传入创建线程Thread对象中
- 4）启动线程（start方法）

package com.knife.callableDemo;import java.util.concurrent.Callable;public class MyCallable implements Callable<String> {@Overridepublic String call() throws Exception {for (int i=1;i<=10;i++){System.out.println(Thread.currentThread().getName()+"----------i=" + i);}return "成功";}}

测试类

package com.knife.callableDemo;import java.util.concurrent.FutureTask;public class DemoCallable {public static void main(String[] args) throws Exception {
//        准备参数MyCallable myCallable = new MyCallable();//        准备一个futureTask对象FutureTask<String> futureTask = new FutureTask<>(myCallable);
//      创建线程Thread thread = new Thread(futureTask);
//     启动线程thread.start();//        等待线程完成后，才能够获取返回的结果（get()方法：获取方法的返回值）String s = futureTask.get();System.out.println(s);System.out.println("---------------------------------");MyCallable myCallable1 = new MyCallable();MyCallable myCallable2 = new MyCallable();FutureTask<String> futureTask1 = new FutureTask<>(myCallable1);FutureTask<String> futureTask2 = new FutureTask<>(myCallable2);Thread thread1 = new Thread(futureTask1);Thread thread2 = new Thread(futureTask2);//        设置线程的优先级thread1.setPriority(1);
//        thread2.setPriority(2);//        获取当前线程的优先级System.out.println(thread1.getPriority());System.out.println(thread2.getPriority());//        启动线程thread1.start();thread2.start();}
}

线程的优先级：

每个线程都有一个"优先级"，优先级可以用整数表示，取值范围为0~10，0为最低优先级，10位最高优先级，当决定哪个线程需要调度时，首先查看是否存在优先级高的可调度线程，如果存在，就从中选择进行调度。
Thread类有三个优先级静态常量：MAX_PRIORITY为10，为线程最高优先级；MIN_PRIORITY取值为1，为线程最低优先级；NORM_PRIORITY取值为5，为线程中间位置的优先级。默认情况下，线程的优先级为NORM_PRIORITY。
特殊情况在于现在计算机都是多核多线程的配置，有可能优先级低的线程比优先级高的线程先运行，优先级高的线程可能比优先级低的线程后运行。
越高的线程获取CPU时间片的次数越多，线程start后就纳入到了线程调度器中统一管理，线程无权主动索取时间片只能被动分配，因此可以通过线程的优先级来最大程度的改善获取时间片的几率。

多线程：

main线程启动两个线程

public class Thread03 {public static void main(String[] args) {T1 t1 = new T1();T2 t2 = new T2();Thread thread1 = new Thread(t1);Thread thread2 = new Thread(t2);thread1.start();//启动第1个线程thread2.start();//启动第2个线程//...}
}class T1 implements Runnable {int count = 0;@Overridepublic void run() {while (true) {//每隔1秒输出 “hello,world”,输出10次System.out.println("hello,world " + (++count));try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}if(count == 60) {break;}}}
}class T2 implements Runnable {int count = 0;@Overridepublic void run() {//每隔1秒输出 “hi”,输出5次while (true) {System.out.println("hi " + (++count));try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}if(count == 50) {break;}}}
}

建议使用实现Runnable接口
在这里插入图片描述
多线程售票系统：（找出问题）
问题：可能会出现票数超卖（例子：当票数剩余1的时候，三个线程同时访问，最后导致票数超卖）

//使用多线程，模拟三个窗口同时售票100张
public class SellTicket {public static void main(String[] args) {//测试
//        SellTicket01 sellTicket01 = new SellTicket01();
//        SellTicket01 sellTicket02 = new SellTicket01();
//        SellTicket01 sellTicket03 = new SellTicket01();
//
//        //这里我们可能会出现超卖..
//        sellTicket01.start();//启动售票线程
//        sellTicket02.start();//启动售票线程
//        sellTicket03.start();//启动售票线程System.out.println("===使用实现接口方式来售票=====");SellTicket02 sellTicket02 = new SellTicket02();//这里我们可能会出现超卖..new Thread(sellTicket02).start();//第1个线程-窗口new Thread(sellTicket02).start();//第2个线程-窗口new Thread(sellTicket02).start();//第3个线程-窗口}
}//使用Thread方式class SellTicket01 extends Thread {private static int ticketNum = 100;//让多个线程共享 ticketNum@Overridepublic void run() {while (true) {if (ticketNum <= 0) {System.out.println("售票结束...");break;}//休眠50毫秒, 模拟try {Thread.sleep(50);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("窗口 " + Thread.currentThread().getName() + " 售出一张票"+ " 剩余票数=" + (--ticketNum));}}
}//实现接口方式
class SellTicket02 implements Runnable {private int ticketNum = 100;//让多个线程共享 ticketNum@Overridepublic void run() {while (true) {if (ticketNum <= 0) {System.out.println("售票结束...");break;}//休眠50毫秒, 模拟try {Thread.sleep(50);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("窗口 " + Thread.currentThread().getName() + " 售出一张票"+ " 剩余票数=" + (--ticketNum));//1 - 0 - -1  - -2}}
}

线程终止：

在这里插入图片描述

public class ThreadExit_ {public static void main(String[] args) throws InterruptedException {T t1 = new T();t1.start();//如果希望main线程去控制t1 线程的终止, 必须可以修改 loop//让t1 退出run方法，从而终止 t1线程 -> 通知方式//让主线程休眠 10 秒，再通知 t1线程退出System.out.println("main线程休眠10s...");Thread.sleep(10 * 1000);t1.setLoop(false);}
}class T extends Thread {private int count = 0;//设置一个控制变量private boolean loop = true;@Overridepublic void run() {while (loop) {try {Thread.sleep(50);// 让当前线程休眠50ms} catch (InterruptedException e) {e.printStackTrace();}System.out.println("T 运行中...." + (++count));}}public void setLoop(boolean loop) {this.loop = loop;}
}

线程常用方法：

在这里插入图片描述

public class ThreadMethod01 {public static void main(String[] args) throws InterruptedException {//测试相关的方法T t = new T();t.setName("老韩");t.setPriority(Thread.MIN_PRIORITY);//1t.start();//启动子线程//主线程打印5 hi ,然后我就中断 子线程的休眠for(int i = 0; i < 5; i++) {Thread.sleep(1000);System.out.println("hi " + i);}System.out.println(t.getName() + " 线程的优先级 =" + t.getPriority());//1t.interrupt();//当执行到这里，就会中断 t线程的休眠.}
}class T extends Thread { //自定义的线程类@Overridepublic void run() {while (true) {for (int i = 0; i < 100; i++) {//Thread.currentThread().getName() 获取当前线程的名称System.out.println(Thread.currentThread().getName() + "  吃包子~~~~" + i);}try {System.out.println(Thread.currentThread().getName() + " 休眠中~~~");Thread.sleep(20000);//20秒} catch (InterruptedException e) {//当该线程执行到一个interrupt 方法时，就会catch 一个 异常, 可以加入自己的业务代码//InterruptedException 是捕获到一个中断异常.System.out.println(Thread.currentThread().getName() + "被 interrupt了");}}}
}

在这里插入图片描述

public class ThreadMethod02 {public static void main(String[] args) throws InterruptedException {T2 t2 = new T2();t2.start();for(int i = 1; i <= 20; i++) {Thread.sleep(1000);System.out.println("主线程(小弟) 吃了 " + i  + " 包子");if(i == 5) {System.out.println("主线程(小弟) 让 子线程(老大) 先吃");//join, 线程插队//t2.join();// 这里相当于让t2 线程先执行完毕Thread.yield();//礼让，不一定成功..System.out.println("线程(老大) 吃完了 主线程(小弟) 接着吃..");}}}
}class T2 extends Thread {@Overridepublic void run() {for (int i = 1; i <= 20; i++) {try {Thread.sleep(1000);//休眠1秒} catch (InterruptedException e) {e.printStackTrace();}System.out.println("子线程(老大) 吃了 " + i +  " 包子");}}
}

在这里插入图片描述

public class ThreadMethodExercise {public static void main(String[] args) throws InterruptedException {Thread t3 = new Thread(new T3());//创建子线程for (int i = 1; i <= 10; i++) {System.out.println("hi " + i);if(i == 5) {//说明主线程输出了5次 hit3.start();//启动子线程 输出 hello...t3.join();//立即将t3子线程，插入到main线程，让t3先执行}Thread.sleep(1000);//输出一次 hi, 让main线程也休眠1s}}
}class T3 implements Runnable {private int count = 0;@Overridepublic void run() {while (true) {System.out.println("hello " + (++count));try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}if (count == 10) {break;}}}
}

用户线程和守护线程

在这里插入图片描述

public class ThreadMethod03 {public static void main(String[] args) throws InterruptedException {MyDaemonThread myDaemonThread = new MyDaemonThread();//如果我们希望当main线程结束后，子线程自动结束//,只需将子线程设为守护线程即可myDaemonThread.setDaemon(true);myDaemonThread.start();for( int i = 1; i <= 10; i++) {//main线程System.out.println("宝强在辛苦的工作...");Thread.sleep(1000);}}
}class MyDaemonThread extends Thread {public void run() {for (; ; ) {//无限循环try {Thread.sleep(1000);//休眠1000毫秒} catch (InterruptedException e) {e.printStackTrace();}System.out.println("马蓉和宋喆快乐聊天，哈哈哈~~~");}}
}

线程的生命周期：

在这里插入图片描述

public class ThreadState_ {public static void main(String[] args) throws InterruptedException {T t = new T();System.out.println(t.getName() + " 状态 " + t.getState());t.start();while (Thread.State.TERMINATED != t.getState()) {System.out.println(t.getName() + " 状态 " + t.getState());Thread.sleep(500);}System.out.println(t.getName() + " 状态 " + t.getState());}
}class T extends Thread {@Overridepublic void run() {while (true) {for (int i = 0; i < 10; i++) {System.out.println("hi " + i);try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}break;}}
}

Synchronized

在这里插入图片描述

public class SellTicket {public static void main(String[] args) {//测试
//        SellTicket01 sellTicket01 = new SellTicket01();
//        SellTicket01 sellTicket02 = new SellTicket01();
//        SellTicket01 sellTicket03 = new SellTicket01();
//
//        //这里我们会出现超卖..
//        sellTicket01.start();//启动售票线程
//        sellTicket02.start();//启动售票线程
//        sellTicket03.start();//启动售票线程//        System.out.println("===使用实现接口方式来售票=====");
//        SellTicket02 sellTicket02 = new SellTicket02();
//
//        new Thread(sellTicket02).start();//第1个线程-窗口
//        new Thread(sellTicket02).start();//第2个线程-窗口
//        new Thread(sellTicket02).start();//第3个线程-窗口//测试一把SellTicket03 sellTicket03 = new SellTicket03();new Thread(sellTicket03).start();//第1个线程-窗口new Thread(sellTicket03).start();//第2个线程-窗口new Thread(sellTicket03).start();//第3个线程-窗口}
}//实现接口方式, 使用synchronized实现线程同步
class SellTicket03 implements Runnable {private int ticketNum = 100;//让多个线程共享 ticketNumprivate boolean loop = true;//控制run方法变量Object object = new Object();//同步方法（静态的）的锁为当前类本身//解读//1. public synchronized static void m1() {} 锁是加在 SellTicket03.class//2. 如果在静态方法中，实现一个同步代码块./*synchronized (SellTicket03.class) {System.out.println("m2");}*/public synchronized static void m1() {}public static  void m2() {synchronized (SellTicket03.class) {//静态方法中，锁要加载类本身System.out.println("m2");}}//说明//1. public synchronized void sell() {} 就是一个同步方法//2. 这时锁在 this对象//3. 也可以在代码块上写 synchronize ,同步代码块, 互斥锁还是在this对象public /*synchronized*/ void sell() { //同步方法, 在同一时刻， 只能有一个线程来执行sell方法synchronized (/*this*/ object) {//同步代码块//调用同一个对象objectif (ticketNum <= 0) {System.out.println("售票结束...");loop = false;return;}//休眠50毫秒, 模拟try {Thread.sleep(50);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("窗口 " + Thread.currentThread().getName() + " 售出一张票"+ " 剩余票数=" + (--ticketNum));//1 - 0 - -1  - -2}}@Overridepublic void run() {while (loop) {sell();//sell方法是一个同步方法}}
}//使用Thread方式
// new SellTicket01().start()
// new SellTicket01().start();
class SellTicket01 extends Thread {private static int ticketNum = 100;//让多个线程共享 ticketNum//    public void m1() {
//        synchronized (this) {
//            System.out.println("hello");
//        }
//    }@Overridepublic void run() {while (true) {if (ticketNum <= 0) {System.out.println("售票结束...");break;}//休眠50毫秒, 模拟try {Thread.sleep(50);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("窗口 " + Thread.currentThread().getName() + " 售出一张票"+ " 剩余票数=" + (--ticketNum));}}
}//实现接口方式
class SellTicket02 implements Runnable {private int ticketNum = 100;//让多个线程共享 ticketNum@Overridepublic void run() {while (true) {if (ticketNum <= 0) {System.out.println("售票结束...");break;}//休眠50毫秒, 模拟try {Thread.sleep(50);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("窗口 " + Thread.currentThread().getName() + " 售出一张票"+ " 剩余票数=" + (--ticketNum));//1 - 0 - -1  - -2}}
}

在这里插入图片描述

线程死锁

在这里插入图片描述

public class DeadLock_ {public static void main(String[] args) {//模拟死锁现象DeadLockDemo A = new DeadLockDemo(true);A.setName("A线程");DeadLockDemo B = new DeadLockDemo(false);B.setName("B线程");A.start();B.start();}
}//线程
class DeadLockDemo extends Thread {static Object o1 = new Object();// 保证多线程，共享一个对象,这里使用staticstatic Object o2 = new Object();boolean flag;public DeadLockDemo(boolean flag) {//构造器this.flag = flag;}@Overridepublic void run() {//下面业务逻辑的分析//1. 如果flag 为 T, 线程A 就会先得到/持有 o1 对象锁, 然后尝试去获取 o2 对象锁//2. 如果线程A 得不到 o2 对象锁，就会Blocked//3. 如果flag 为 F, 线程B 就会先得到/持有 o2 对象锁, 然后尝试去获取 o1 对象锁//4. 如果线程B 得不到 o1 对象锁，就会Blocked
//当线程A（true）拿了o1之后，需要拿到o2才能继续进行下去，而线程B（false）进入到else语句，获取到了o2后也需要获取o1才能继续进行下去，之后就导致卡死在这互斥锁里面了if (flag) {synchronized (o1) {//对象互斥锁, 下面就是同步代码System.out.println(Thread.currentThread().getName() + " 进入1");synchronized (o2) { // 这里获得li对象的监视权System.out.println(Thread.currentThread().getName() + " 进入2");}}} else {synchronized (o2) {System.out.println(Thread.currentThread().getName() + " 进入3");synchronized (o1) { // 这里获得li对象的监视权System.out.println(Thread.currentThread().getName() + " 进入4");}}}}
}