1. 线程两个基本概念
- 并发：即线程交替运行多个指令
- 并行：即多个线程同时运行指令
- 并发并行不矛盾，两者可同时发生，即多个线程交替运行指令
2. 多线程3种实现方式
2.1 直接创建线程对象
/*
*
* 方式1：
* 1. 创建thread类的子类
* 2. 将该子类实列化
* 3. 实列化对象调用start方法即开启多线程
* */
myThread myThread1 = new myThread();
myThread1.setName("线程1");
myThread1.start();
myThread myThread2 = new myThread();
myThread2.setName("线程2");
myThread2.start();
public class myThread extends Thread{
@Override
public void run() {
for (int i = 0; i < 20; i++) {
System.out.println(getName() + "看看哪个线程在执行指令");
}
}
}2.2 实现Runnable接口
//方法2：
/*
* 1. 定义类实现runnable接口
* 2. 重写Runnable接口的run方法
* 3. 创建自己类对象
* 4. 创建线程，将自己类这个指令添加到线程，开启线程
* */
//因为没有继承thread类，无法直接调用start方法，此时该类对象充当要执行的指令，再把该指令添加到线程中即可
//可直接获取线程对象，或者调用thread类里面获取线程对象的方法
mythread mt1 = new mythread();
Thread t1 = new Thread(mt1);
Thread t2 = new Thread(mt1);
t1.setName("线程1");
t2.setName("线程2");
t1.start();
t2.start();
}
public class mythread implements Runnable{
@Override
public void run() {
for (int i = 0; i < 20; i++) {
System.out.println(Thread.currentThread().getName() + "第二个方法哟");
}
}
}2.3 利用Callable、Future接口
//方法3：利用Callable、Future接口实现
/*
* 1. 定义类实现Callable接口，并重写该接口的call方法
* 2. 创建自己类的对象（即将要执行的指令对象）
* 3. 创建FutureTask对象（即接收执行指令最终返回的结果）
* 4. 创建Thread对象（将要执行的指令添加到线程对象中），并开启线程
* */
//1. 定义类，实现Callable接口，并且重写call方法
//2. 创建指令类对象
mythread mythread = new mythread();
//3. 创建接收指令类返回结果的FutureTask对象，此时里面参数代表接收该指令类对象返回的参数
FutureTask<Integer> integerFutureTask = new FutureTask<Integer>(mythread);
//将指令添加到线程对象中
Thread thread = new Thread(integerFutureTask);
thread.start();
System.out.println(integerFutureTask.get());
public class mythread implements Callable<Integer> {
@Override
public Integer call() throws Exception {
int sum = 0;
for (int i = 1; i < 10; i++) {
sum += i;
}
return sum;
}
}三者区别：
- 第一种实现方式扩展性较差，因为要有继承关系即已经继承了Thread类，那么该类无法在继承别的类，而方式2、3定义的类只是实现了接口，还可以继承其他类，扩展性较好
- 第二种方式相对第三种语法较为简洁
- 第三种可以获取指令最终的返回结果，适用于需要返回结果的场景，前两种方式无返回值，无法获取指令的返回结果
3. 线程常用方法
3.1 线程优先级
优先级高的线程先执行的概率更高，但不是绝对，线程的执行时机都是随机事件概率问题，Java中默认的线程默认优先级为5，可以调用方法更改线程的优先级
3.2 守护线程
当未守护线程全都执行完毕守护线程也随之结束
3.3 礼让线程
礼让线程可让线程的执行尽可能的均匀
public class yieldThread implements Runnable{
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName() + "礼让线程鸭");
Thread.yield();
}
}
}3.4 插入线程
Java虚拟机默认先执行完main线程在执行其他线程，若要其他线程在main线程之前执行可调用插入线程方法
//插入线程
/*
* 执行线程：
* 虚拟机默认先执行main线程，当main线程执行完毕在执行其他线程，若想其他线程在main线程之前执行，得调用插入线程方法
* */
//创建要执行指令的对象
joinThread jt = new joinThread();
//创建线程对象，要执行的指令添加进线程
Thread t = new Thread(jt);
//执行线程
//插入线程
t.start();
t.join();
for (int i = 0; i < 10; i++) {
System.out.println("main线程在执行哟");
}4. 线程生命周期
5. 解决多线程问题
5.1 同步代码块
用于解决线程安全问题，需要用到synchronized关键字
public class windowThread implements Runnable {
static int ticket = 0;
@Override
public void run() {
//定义个卖票指令，实现多个窗口同时买票
while (true) {
//若要避免线程安全问题，可用到synchronized关键字，括号里面的对象充当门锁，默认是打开的，当有线程对象进去，门锁关闭
//如：此时窗口1争夺到cpu的执行权，那么就会进去，到了sleep睡眠时此时没有资格争夺cpu执行权，假设此时窗口2争夺到
//但是因为窗口1已经进去门锁此时关闭，而争夺执到执行权的窗口2也只能在门外等候，等待窗口1出来才门才会开锁
//此时的门锁可以避免多条线程同时执行下面的代码块，从而引发同一张票被3个窗口同时卖出的线程安全问题
/*
*
* 锁细节：
* 所有线程对象用到的门锁必须是唯一的，
* 一般用类的字节码文件作为锁对象，保证锁的唯一性
* */
synchronized (windowThread.class) {
if (ticket < 100) {
try {
//一旦线程运行到此处即休眠10毫秒，无法争夺cpu执行权，休眠过后继续执行后面代码
//只有该线程执行完synchronized的代码锁才会打开
Thread.sleep(10);
ticket++;
System.out.println(Thread.currentThread().getName() + "正在卖第" + ticket + "张票");
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
} else {
break;
}
}
}
}
}5.2 同步方法
被synchronized关键字修饰的方法为同步方法，该方法执行完才会开锁
public class myRunnable implements Runnable {
int ticket = 0;
@Override
public void run() {
while (true) {
//同步方法：即将同步代码块抽取成方法即可
//被synchronized即同步方法，当一个方法的代码全部要被锁起来可以运用到该方式
if (method()) break;
}
}
private synchronized boolean method() {
if (ticket < 100) {
try {
Thread.sleep(10);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
ticket++;
System.out.println(Thread.currentThread().getName() + "正在卖第" + ticket + "张票");
} else {
return true;
}
return false;
}
}6. 锁（Lock）
synchronized关键字修饰的代码块会自动进行开关锁，而不用这个关键字也开业手动开关机解决线程问题
public class mtThread extends Thread {
static int ticket = 0;
//创建锁对象，因为此时定义的类继承Thread类，即会有很多线程对象，
//而静态关键字修饰的锁对象不管该类实列化多少对象，该锁都仅有一个
//确保了每个实例化对象对应的锁的唯一性
static Lock lock = new ReentrantLock();
@Override
public void run() {
while (true) {
//手动关锁，当线程对象进入后，未开锁之前其他对象不能进入锁下面的代码块
lock.lock();
try {
if (ticket == 100) {
break;
} else {
//线程对象执行到此处一样会进行休眠，不参与争夺cpu
//当其他线程对象争夺到cpu时会被关在锁外，即无法执行此时的try、catch语句
//只有当锁重新打开才能继续执行
Thread.sleep(10);
ticket++;
System.out.println(Thread.currentThread().getName() + "正在售卖第" + ticket + "张票");
}
} catch (InterruptedException e) {
throw new RuntimeException(e);
} finally {
//打开锁，获得cpu运行权的对象开锁执行代码
lock.unlock();
}
}
}
}7. 死锁
当两个锁嵌套使用时容易产生死锁问题，当死锁发生，程序将会卡死在锁的门外无法在运行下去，故锁不能嵌套使用
8. 唤醒等待机制
唤醒等待机制可以使线程协调运行，比如线程1运行一次，线程2也运行一次
生产者和消费者实现唤醒等待机制
public class test {
public static void main(String[] args) {
//等待唤醒机制：使得线程协调运行
/*
* 三个对象：
* 1. 生产者
* 2. 消费者
* 3. 平台
* */
Consumer consumer = new Consumer();
Producer producer = new Producer();
consumer.setName("消费者");
producer.setName("生产者");
consumer.start();
producer.start();
}
}
public class Desk {
//三个属性作为协调的依据
//判断当前桌子上是否有食物（线程是否运行）
// 0:没有食物 1：有食物
static int foodFlag = 0;
//判断当前食物运行次数还剩多少（线程运行次数）
static int count = 10;
//锁对象
static Lock lock = new ReentrantLock();
}
public class Consumer extends Thread{
/*
*
* 1. 判断线程次数是否完成
* 2. 判断桌子上是否有食物
* 3. 有食物则吃掉，次数减一
* 4. 没有食物则等候，并且唤醒生产者
* */
@Override
public void run() {
while (true) {
synchronized (Desk.lock) {
//判断线程次数
if (Desk.count == 0) {
break;
}
//判断是否有食物
if (Desk.foodFlag == 1) {
//有则直接吃掉，并且次数减一
System.out.println(this.getName() + "正在吃掉第" + Desk.count + "份食物");
//吃掉之后则生产者继续生产（即唤醒另一线程）
Desk.lock.notify();
Desk.foodFlag = 0;
Desk.count--;
} else {
try {
//让该线程和锁进行绑定
Desk.lock.wait();
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
}
}
}
public class Producer extends Thread{
/*
*
* 1. 判断线程次数是否运行完成
* 2. 判断桌面上是否有食物（该线程是否运行）
* 3. 有则等候（线程等候），并唤醒等候线程
* 4. 没有则做食物（线程运行）
* */
@Override
public void run() {
while (true) {
synchronized (Desk.lock) {
//判断线程次数是否运行完成
if (Desk.count == 0) {
break;
}
if (Desk.foodFlag == 1) {
//有则等候，并唤醒该锁对象的等候线程
try {
//让该线程和锁进行帮
Desk.lock.wait();
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
} else {
//没有则做食物
System.out.println(this.getName() + "正在制作第" + Desk.count + "份食物");
//制作之后则消费者消费（即唤醒另一线程）
Desk.lock.notify();
Desk.foodFlag = 1;
}
}
}
}
}阻塞队列实现唤醒等待机制
用到Java提供的队列类（BlockingQueue）此时的队列充当平台，线程之间数据交换协调的平台，要保证线程在同一队列之间协调运行
public class test {
public static void main(String[] args) {
//阻塞队列实现唤醒等待机制
/*
*
* 生产者
* 消费者
* 队列：生产者和消费者必须在同一队列进行生产消费
* */
//创建队列对象
ArrayBlockingQueue<String> queue = new ArrayBlockingQueue<String>(3);
//创建两条线程
Consumer c = new Consumer(queue);
Producer p = new Producer(queue);
p.start();
c.start();
}
}
public class Producer extends Thread{
ArrayBlockingQueue<String> queue;
//要保证在同一队列进行生产消费，可在构造方法中传递队列对象
public Producer(ArrayBlockingQueue<String> queue) {
this.queue = queue;
}
//重写线程运行方法
@Override
public void run() {
while (true) {
try {
//该队列的方法中已经写好开关锁，不需要我们自己写锁
queue.put("好吃的鸭");
System.out.println("做了好吃的鸭");
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
}
public class Consumer extends Thread{
ArrayBlockingQueue<String> queue;
//获取队列对象，要保证同一队列可在构造方法中传递队列对象
public Consumer(ArrayBlockingQueue<String> queue) {
this.queue = queue;
}
//重写Run方法
@Override
public void run() {
while (true) {
try {
//该队列已经写好开关锁，不需要我们手动写，若在写锁就造成嵌套锁容易形成死锁问题
String food = queue.take();
System.out.println(food);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
}
9. 线程池
没有线程池存放线程时，我们创建的线程当运行完毕会自动销毁，而线程池可以存储线程，提高资源复用率
线程池原理
- 创建线程池时，里面是空的，没有任何线程
- 当有任务添加进线程池时，先创建线程，运行任务，当任务运行完毕，线程并不会销毁，而是保留在池子中，若在有新任务添加，而原先创建的线程并没有运行任务，则会直接复用线程，并不会立刻创建新线程·
- 当线程池的线程数量达到线程池规定数量上限就不会在创建新线程，而未运行到的任务只能排队等待
获取线程池对象的方式
用工具类 Executors直接创建
未完待续......
