多线程
- 进程：在计算机中正在运行的任务；每个进程都会有独立的内存空间和系统资源
- 线程：基于进程而存在，是进程执行的基本单位；一个进程一般有多个线程；多个线程共享当前进程的内存资源的系统资源；每个线程想执行都得抢占CPU资源，抢占的可能性是随机的；
- main方法运行本身就会启动一个线程 — 主线程
Thread类
- 构造方法：
Thread(String name)：分配新的 Thread 对象，name 为新线程的名称。Thread(Runnable target)：分配新的 Thread 对象Thread(Runnable target, String name)：分配新的 Thread 对象并指定线程名称。
- 方法
String getName()：返回该线程的名称。static Thread currentThread()：返回对当前正在执行的线程对象的引用。static void sleep(long millis)：程序执行到sleep方法，就根据指定的时间来暂停当前线程运行；当时间结束时恢复运行；void setName(String name)：改变线程名称，使之与参数 name 相同。void start()：使该线程开始执行；Java 虚拟机调用该线程的 run 方法
自定义线程 — 三种方式
方式一：
- 自定义类继承
Thread - 重写
run()，run()定义的是当前线程要执行的内容 - 创建一个线程的对象
- 调用对象的方法 —
start()来启动线程
public class ThreadDemo1 {
public static void main(String[] args) {
// 3. 创建线程对象
MyThread my = new MyThread("线程1");
// 4. 调用start()启动线程
// 一个线程只能启动一次
my.start();
MyThread my1 = new MyThread("线程2");
my1.start();
}
}
// 1. 自定义类继承 Thread
class MyThread extends Thread{
public MyThread(String name){
super(name);
}
@Override
// 2. 重写run()，run()定义的是当前线程要执行的内容
public void run() {
// 循环打印数字
for (int i = 0; i <= 50; i++){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(this.getName() + ":" + i);
}
}
}
方式二：
- 自定义类实现
Runnable接口 - 实现
run() - 创建线程类对象，该对象身上没有
start()，需要创建Thread类对象，将自定义的线程对象作为参数传入 - 调用
start()来启动线程
public class ThreadDemo2 {
public static void main(String[] args) {
// 创建线程类对象
MyThread1 myThread1 = new MyThread1();
// 调用start对象启动线程
// Runnable接口本身没有start()
// 创建Thread类对象
Thread t1 = new Thread(myThread1);
t1.start();
}
}
// 自定义类实现Runnable接口
class MyThread1 implements Runnable{
@Override
public void run() {
// 实现run()
for (int i = 0; i <= 50; i++){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + ":" + i);
}
}
}
方式三：
- 自定义类实现Callable接口
- 实现call方法
- 从线程池获取一个线程服务对象
- 调用对象的submit方法，把自定义的线程类对象作为参数传入，返回值存储到Future对象中
- 打印返回值
public class ThreadDemo3 {
public static void main(String[] args) throws ExecutionException, InterruptedException {
// 线程服务对象
ExecutorService es = Executors.newCachedThreadPool();
// 创建线程并运行线程
Future<String> future = es.submit(new MyThread2());
// 打印返回值
System.out.println(future.get());
}
}
class MyThread2 implements Callable<String> {
@Override
public String call() throws Exception {
for (int i = 0; i <= 10; i++){
System.out.println(i);
}
return "hello~";
}
}
面试题：
- run()和start()的区别？：run() — 线程执行的代码逻辑； start() — 直接调用启动线程； 如果直接调用线程的run()，并不是启动了新线程，而是在原来的线程中调用run()。
- 如何启动线程？：调用start()，当线程启动之后，Java虚拟机会去调用线程重写的run()
注意：创建线程推荐使用实现Runnable接口的形式
多线程并发安全问题
-
每个线程每时每刻都在尝试抢占CPU的资源
-
为什么会出现多线程安全问题？
- 多个线程
- 多个线程共享同一个数据资源
- 共享数据资源被多行代码使用
-
针对问题3，可以使用同步锁机制来解决这一个问题
-
同步代码块
synchronized (锁对象){ // 此处代码块就会被锁起来 }锁对象：必须得所有的线程都认识；要求对所有的线程都一致；可能是任意对象、this、类.class
public class TicketDemo3 { public static void main(String[] args) { SellTicket3 s1 = new SellTicket3(new Ticket(100)); new Thread(s1,"窗口1").start(); new Thread(s1,"窗口2").start(); new Thread(s1,"窗口3").start(); } } class SellTicket3 implements Runnable{ private Ticket ticket; public SellTicket3(Ticket ticket){ this.ticket = ticket; } @Override public void run() { while(true) { try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } synchronized (ticket) { if (ticket.getNum() > 0) { try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("当前剩余" + ticket.getNum() + "张票 --- " + Thread.currentThread().getName() + "有人购票"); ticket.setNum(ticket.getNum()-1); } } } } } class Ticket{ private int num; public Ticket(int num) { this.num = num; } public int getNum() { return num; } public void setNum(int num) { this.num = num; } } -
同步方法
public synchronized 返回值 方法名(){ // ... }- 在方法定义上加synchronized关键字，该方法就不会有多线程安全问题
- 锁对象是：this当前对象
public class TicketDemo4 { public static void main(String[] args) { SellTicket4 s1 = new SellTicket4(new Ticket(100)); // 简化代码 new Thread(s1,"窗口1").start(); new Thread(s1,"窗口2").start(); new Thread(s1,"窗口3").start(); } } class SellTicket4 implements Runnable{ private Ticket ticket; public SellTicket4(Ticket ticket){ this.ticket = ticket; } @Override public void run() { while(true) { try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } sell(); } } public synchronized void sell(){ if (ticket.getNum() > 0) { try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("当前剩余" + ticket.getNum() + "张票 --- " + Thread.currentThread().getName() + "有人购票"); ticket.setNum(ticket.getNum()-1); } } } -
静态同步方法
public static synchronized 返回值 方法名(){ // ... }锁对象：类.class — 字节码文件对象
class SellTicket5 implements Runnable{ private static Ticket ticket; public SellTicket5(Ticket ticket) { this.ticket = ticket; } @Override public void run() { while (true){ try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } synchronized (this){ sell(); } } } public static synchronized void sell(){ if (ticket.getNum() >0){ try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("当前剩余" + ticket.getNum() + "张票 --- " + Thread.currentThread().getName() + "有人购票"); ticket.setNum(ticket.getNum()-1); } } }
- 同步锁的优点和缺点
- 优点：提高了程序的安全性
- 缺点：降低了程序执行的效率
死锁
案例演示
打印机：打印 扫描仪：扫描
员工一：先打印（锁定打印方法），打印中途需要扫描（等待）
员工二：先扫描（锁定扫描方法），扫描中途需要打印（等待）
public class DeadLockDemo {
private static Printer printer = new Printer();
private static Scanner scanner = new Scanner();
public static void main(String[] args) {
// 使用匿名内部类的形式创建线程
// 员工1：先打印后扫描
new Thread(new Runnable() {
@Override
public void run() {
while(true){
synchronized (printer) {
// 打印
System.out.println(Thread.currentThread().getName());
printer.print();
synchronized (scanner){
// 扫描内容
System.out.println(Thread.currentThread().getName());
scanner.scan();
}
}
}
}
}, "员工1").start();
// 员工2：先扫描后打印
new Thread(new Runnable() {
@Override
public void run() {
while(true){
synchronized (scanner) {
// 扫描
System.out.println(Thread.currentThread().getName());
scanner.scan();
synchronized (printer){
// 打印内容
System.out.println(Thread.currentThread().getName());
printer.print();
}
}
}
}
}, "员工2").start();
}
}
// 打印机
class Printer{
public void print(){
System.out.println("打印机正在打印~");
}
}
// 扫描仪
class Scanner{
public void scan(){
System.out.println("扫描仪正在扫描~");
}
}
为什么会出现死锁?
- 多线程
- 共享数据资源
- 有多个锁对象，锁的嵌套
如何避免死锁?
- 注意尽量减少锁对象，避免锁的嵌套
线程通信
案例演示:
学生问问题的案例
学生类：姓名 性别
问问题的线程，一直执行；一男一女两个学生交替问问题
等待唤醒机制
- 锁对象的
wait()：可以让线程进入等待，当线程进入等待且没有被唤醒的情况下，当前线程会释放资源 - 锁对象的
notify()：可以唤醒一个线程；被唤醒的线程从之前等待的位置继续向下执行 - 标记位：为了控制程序先运行哪个线程，所以设置了一个标记位
注意：等待唤醒机制一般都是结合synchronized进行使用的；
public class TXDemo {
public static void main(String[] args) {
Student student = new Student("Sam",'男');
// 启动问问题的线程
new Thread(new AskProblem(student)).start();
// 启动切换学生的线程
new Thread(new Change(student)).start();
}
}
// 问问题
class AskProblem implements Runnable{
private Student student;
public AskProblem(Student student) {
this.student = student;
}
@Override
public void run() {
while (true) {
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (student) {
// 如果上一次打印过了，停一下
if(!student.flag){
try {
student.wait(); // 当线程执行到本行代码时会等待
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(student + " is asking~");
student.flag = false;
student.notify(); // 唤醒一个正在等待的线程
}
}
}
}
// 切换学生
class Change implements Runnable{
private Student student;
public Change(Student student) {
this.student = student;
}
@Override
public void run() {
while(true){
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (student) {
// 如果上一次改变过学生信息了，停一下
if (student.flag) {
try {
student.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
if (student.gender == '男') {
student.name = "lili";
student.gender = '女';
} else {
student.name = "Sam";
student.gender = '男';
}
student.flag = true;
student.notify(); // 唤醒一个正在等待的线程
}
}
}
}
class Student{
String name;
char gender;
// 标记位，标记谁先执行
boolean flag = true; // 如果flag为true，则执行AskProblem线程
public Student(String name, char gender) {
this.name = name;
this.gender = gender;
}
@Override
public String toString() {return name + "," + gender;}
}
上述代码会出现的问题：
-
当有四个线程（两个问问题的线程和两个切换学生的线程）同时运行时，无法按照预定的形式输出
- 原因：使用
notify()：可以唤醒一个线程；被唤醒的线程从之前等待的位置继续向下执行 - 解决方案：将
if (student.flag)和if (!student.flag)修改为while (student.flag)和while (!student.flag)每一次都对flag的值进行判断
- 原因：使用
-
修改之后造成的问题：循环若干次后，全部线程处于
wait状态，无法被唤醒
-
原因：当线程池等待时，会将等待的线程放到一个线程池中；线程池的底层其实是通过队列（先进先出）实现的
假设有A1, A2, C1, C2 四个线程 初始状态 flag=true
-
四个线程抢，假设A1抢到了；因为true，A1可以正常执行；将flag置为false;
-
假设A1又抢到了，此时flag=false, A1进入等待；
-
假设A2抢到了，此时flag=false, A2进入等待；
-
假设C1抢到了，此时flag=false，C1正常执行；flag置为true; 唤醒A1；
-
假设C2抢到，此时flag=true，C2进入了等待；
-
假设C1抢到，此时flag=true，C1进入了等待；
-
只剩A1了，所以A1抢到了，flag置为false; 唤醒A2；
-
假设A1抢到了，flag=false, A1进入等待；
-
只剩A2了，flag=false, A2进入等待；
-
到此，四个线程全部进入等待；
-
- 解决方案：通过
notifyAll方法，唤醒全部线程
生产者 - 消费者模式
示例：
奶箱类 (Box)：定义一个成员变量，表示第x瓶奶，提供存储牛奶和获取牛奶的操作
生产者类 (Producer):实现Runnable接口，重写run()方法，调用存储牛奶的操作
消费者类 (Customer):实现Runnable接口，重写run()方法，调用获取牛奶的操作
public class BoxDemo {
public static void main(String[] args) {
// 创建奶箱对象，这是共享数据区域
Box b = new Box();
// 创建生产者对象，把奶箱对象作为构造方法传递
Producer producer = new Producer(b);
// 创建消费者对象，把奶箱对象作为构造方法传递
Customer customer = new Customer(b);
Thread t1 = new Thread(producer);
Thread t2 = new Thread(customer);
t1.start();
t2.start();
}
}
class Box {
// 定义一个成员变量，表示第x瓶奶
private int milk;
// 定义一个成员变量，表示奶箱的状态
boolean flag = false;
// 提供存储牛奶和获取牛奶的操作
public void put(int milk) {
// 如果有牛奶, 等待消费
if (flag){
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
// 如果没有牛奶(flag == false)，生产牛奶
this.milk = milk;
System.out.println("送奶工将" + this.milk + "瓶奶放入奶箱");
flag = true;
notifyAll();
}
public void get() {
// 如果没有牛奶等待生产
if (! flag){
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
// 如果有牛奶，就消费牛奶
System.out.println("用户拿到第" + this.milk + "瓶奶");
flag = false;
notifyAll();
}
}
class Producer implements Runnable {
private Box b;
public Producer(Box b) {
this.b = b;
}
@Override
public void run() {
for (int i = 1; i <=5; i++){
synchronized (b) {
b.put(i);
}
}
}
}
class Customer implements Runnable {
private Box b;
public Customer(Box b) {
this.b = b;
}
@Override
public void run() {
while(true){
synchronized (b) {
b.get();
}
}
}
}
守护线程
-
用来守护其他线程的
-
特点：
- 当被守护的线程结束，守护线程也随之结束；
- 守护线程也可以在被守护线程之前结束；
示例（王者荣耀）：
水晶：血量 --- > 线程
小兵：血量 --- > 守护线程
public class DaemonDemo {
public static void main(String[] args) {
Thread t1 = new Thread(new Crystal());
t1.setName("水晶");
Thread t2 = new Thread(new Soldier());
t2.setName("小兵1");
Thread t3 = new Thread(new Soldier());
t3.setName("小兵2");
Thread t4 = new Thread(new Soldier());
t4.setName("小兵3");
// 设置小兵线程为守护线程
t2.setDaemon(true);
t3.setDaemon(true);
t4.setDaemon(true);
// 启动线程
t1.start();
t2.start();
t3.start();
t4.start();
}
}
class Soldier implements Runnable{
private int life = 100;
@Override
public void run() {
for (int i = life; i>= 0; i--){
synchronized (Soldier.class){
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println( Thread.currentThread().getName()+"当前血量为："+i);
}
}
}
}
class Crystal implements Runnable{
private int life = 200;
@Override
public void run() {
for (int i = life; i>= 0; i--){
synchronized (Crystal.class){
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println( Thread.currentThread().getName()+"当前血量为："+i);
}
}
}
}
问题：java中最常见的守护线程是谁？
- GC：垃圾回收
线程的优先级及状态
线程的调度模型
- 分时调度模型：所有线程轮流使用CPU的使用权，平均分配每个线程占用CPU的时间片
- 抢占式调度模型：优先让优先级高的线程使用CPU，如果线程优先级相同，那么会随机选择一个，优先级高的线程获取的CPU时间片相对多一些
- java使用的是抢占式调度模型
优先级：
- 分为1-10等级，默认情况下，所有线程的优先级都是5，指定优先级，可以提高抢占资源的概率，但是如果优先级差别在5以内，效果基本不明显
- 方法：
- 设置优先级：
setPriority(int newPriority) - 获取优先级：
getPriority()
- 设置优先级：
线程的状态：
-
创建状态 ：在程序中用构造方法创建了一个线程对象后，新的线程对象便处于新建状态，此时它已经有了相应的内存空间和其他资源，但还处于不可运行状态
-
就绪状态 ：新建线程对象后，调用该线程的
start()方法就可以启动线程。当线程启动时，线程进入就绪状态。 -
运行状态 ：当就绪状态被调用并获得处理器资源时，线程就进入了运行状态。此时，自动调用该线程对象的
run()方法。run()方法定义该线程的操作和功能。 -
阻塞状态 : 一个正在执行的线程在某些特殊情况下，如被人为挂起或需要执行耗时的输入/输出操作，会让 CPU 暂时中止自己的执行，进入阻塞状态。在可执行状态下，如果调用
sleep(),wait()等方法，线程都将进入阻塞状态 -
消亡状态: 线程调用
stop()方法时或run()方法执行结束后，即处于消亡状态。处于消亡状态的线程不具有继续运行的能力。
面试题
-
sleep和wait方法区别？
sleep:可以指定时间，当执行到sleep方法时，当前线程不再抢占资源；当时间结束，就恢复运行
wait：当程序执行到wait之后，会释放资源；当notify唤醒，才会恢复运行
-
同步和异步：
同步：只有一个线程可以执行，效率低
异步：可以多个线程同时执行，效率高
同步线程安全、异步线程不安全
-
线程安全的类：StringBuffer、Vector、Hashtable
488
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
