进程与线程
在操作系统中，正在运行的程序称为进程，进程负责程序内存空间的分配。
进程包含线程，每条线程都是进程中代码的一条执行路径，是进程的实际运作单位。
一个进程中可以并发多个线程，每条线程并行执行不同的任务。
多线程
在一个进程中有多个线程同时在执行不同的任务的行为。
一个Java应用程序中至少有两个线程：一个是主线程，负责main方法代码的执行，一个是垃圾回收器线程，负责回收垃圾。
能让一个进程同时执行多个任务，提高资源的利用率（不是效率）。
多线程的弊端
增加了CPU的负担，降低了一个进程中线程的执行概率。
会引发线程安全问题，出现了死锁现象。
线程的生命周期
线程生命周期图
线程的实现方式
public class Main {
public static void main(String[] args) {
1.继承方式开启线程
Demo1 demo = new Demo1();
demo.start();
2.实现接口方式开启线程
Demo2 demo2 = new Demo2();
Thread thread = new Thread(demo2);
thread.start();
}
}
1.继承方式开启线程
class Demo1 extends Thread {
@Override
public void run() {
super.run();
}
}
2.实现接口方式开启线程
class Demo2 implements Runnable {
@Override
public void run() {
}
}
匿名内部类方式开启线程
public static void main(String[] args) {
new Thread(new Runnable() {
@Override
public void run() {
}
}).start();
}
接口实现方式开启线程的细节
Runnable实现类的对象，不是线程对象，只是Runnable实现类的对象。
只有Thread或者Thread子类的对象才是线程对象，所以需要将Runnable实现类对象作为参数，放入Thread构造方法中。推荐使用接口实现的方式，因为Java的单继承，多实现。
从源码看，Runnable实现类的对象作为实参传递给Thread的作用
//SellTicket是Runnable的实现类
SellTicket sellTicket = new SellTicket();
//开启一个线程，将sellTicket传入，看这一段的源码
Thread thread1 = new Thread(sellTicket, "1号");
//源码
public Thread(Runnable target, String name) {
init(null, target, name, 0);
}
//Thread的构造方法接收sellTicket，然后看看Thread.run()开启线程源码
@Override
public void run() {
if (target != null) {
target.run();
}
}
//意思是在Thread类的run中调用了将传入的实现类的run方法，因此能开启线程
线程中常用的方法
| 方法 | 作用 |
|---|---|
| Thread(String name) | 设置线程名称 |
| setName(String name) | 设置线程名称 |
| getName() | 获取线程名称 |
| setPriority(int prioity) | 设置线程的优先级(1~10) |
| getPriority() | 获取线程的优先级 |
public static void main(String[] args) {
Thread thread = new Thread(new Demo(), "线程1");
thread.setName("重新设置线程名称");
System.out.println(thread.getName());
// 线程的优先级默认为5,优先级的范围为1~10
thread.setPriority(10);
thread.getPriority();
Thread.currentThread().getPriority();
thread.start();
}
class Demo implements Runnable {
@Override
public void run() {
}
}
| 静态方法 | 作用 |
|---|---|
| sleep(long time) | 在哪个线程调用，哪个就睡眠 |
| currentThread() | 在哪个线程调用，就返回哪个线程的对象 |
public static void main(String[] args) throws InterruptedException {
Thread thread = new Thread(new Demo(), "线程1");
Thread.sleep(1000); //主线程睡眠
Thread threadMain = Thread.currentThread(); //返回主线程对象
System.out.println("返回主线程：" + threadMain.getName());
thread.start();
}
class Demo implements Runnable {
@Override
public void run() {
// 为什么这里的异常只能捕获处理，不能抛出处理。
//因为Thread类的run()方法没有抛出异常，因此子类不能抛出。
try {
Thread.sleep(1000); //子线程睡眠
Thread threadChild = Thread.currentThread();//返回子线程对象
System.out.println("返回子线程：" + threadChild.getName());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
定时器
public static void main(String[] args) {
Timer定时器工具类，会在主线程之外发起一个单独的线程执行指定的计划任务。
TimerTask是一个实现了Runnable接口的抽象类，代表一个可以被Timer执行的任务。
new Timer().schedule(new TimerTask() {
int count = 0;
@Override
public void run() {
System.out.println("" + count++);
}
}, 1000, 2000);1s后执行，每隔2s触发一次
}
线程安全问题
出现线程安全问题的原因
存在两个或两个以上的线程对象，操作共享同一个资源。
public static void main(String[] args) {
SellTicket sellTicket = new SellTicket();
for (int i = 1; i <= 3; i++)
new Thread(sellTicket, "线程" + i).start();
}
class SellTicket implements Runnable {
//待售票
//这里区别于Thread的方式，不需要用static，因为操作的是一个对象
private int ticket = 50;
@Override
public void run() {
while (true) {
if (ticket > 0) {
System.out.println(
Thread.currentThread().getName()
+ "销售了第："
+ ticket
+ "号票");
ticket--;
} else {
System.out.println("票已售完");
break;
}
}
}
}
线程紊乱
解决线程安全的办法
1.使用synchronized 同步代码块解决
synchronized (锁对象){
}
注意
1.任意的对象都可以作为锁对象，但是，多线程操作的锁对象必须是共享唯一的对象，可用Object。
2.只有真正存在线程安全问题的时才使用同步代码块，否则会降低效率。
3.在同步代码块中调用了sleep()方法，并不释放锁。
4.凡是对象内部都维护了一个状态，Java同步机制就是使用这个状态作为锁的标识。
class SellTicket implements Runnable {
private int ticket = 50;
@Override
public void run() {
while (true) {
//添加同步代码块
synchronized (this) {
if (ticket > 0) {
System.out.println(
Thread.currentThread().getName()
+ "销售了第："
+ ticket
+ "号票");
ticket--;
} else {
System.out.println("票已售完");
break;
}
}
}
}
}
2.使用 synchronized 同步函数解决
将 synchronized 添加到需要同步的函数上
public synchronized void run() {
}
注意
1.同步函数的锁对象是固定的，不能由自己指定。
2.如果是一个非静态的同步函数，那么它的锁对象是this，它本身。
3.如果是静态的同步函数，那么它的锁对象是当前函数所属类的字节码文件(class对象)。
class SellTicket implements Runnable {
private int ticket = 50;
@Override //添加同步函数
public synchronized void run() {
while (true) {
if (ticket > 0) {
System.out.println(
Thread.currentThread().getName()
+ "销售了第："
+ ticket
+ "号票");
ticket--;
} else {
System.out.println("票已售完");
break;
}
}
}
}
推荐使用同步代码块
1.同步代码块的锁对象可以自由指定，方便控制，而同步函数的锁对象是固定的。
2.同步代码块可以控制同步代码的范围，同步函数作用范围是整个函数，将函数内所有代码都同步。
3.使用 Lock 来代替 synchronized
public static final ReentrantLock LOCK = new ReentrantLock();
public void run() {
LOCK.lock();
try {
//线程的操作资源
} finally {
LOCK.unlock();
}
}
class SellTicket implements Runnable {
private int ticket = 50;
public static final ReentrantLock LOCK = new ReentrantLock();
@Override
public void run() {
while (true) {
LOCK.lock();
try {
if (ticket > 0) {
System.out.println(
Thread.currentThread().getName()
+ "销售了第："
+ ticket
+ "号票");
ticket--;
} else {
System.out.println("票已售完");
break;
}
} finally {
LOCK.unlock();
}
}
}
}
线程通信
1.使用 wait()，notify() 实现线程通信
线程通信指当一个线程完成自己的任务时，就去通知另外一个线程去完成另外一个任务。
wait()
1.线程执行wait()后，将进入以锁对象为标识符的线程池中等待。
2.等待状态下，只能被其他线程调用notify()才能唤醒。
3.执行wait()会释放锁。
notify()
线程执行了notify()后，将唤醒以锁对象为标识符在线程池中等待的线程中的一个。
notifyAll()
唤醒线程池中所有等待的线程。
注意
1.wait()，notify()必须由锁对象调用。
2.wait()，notify()必须在同步代码块或者同步函数中使用。
3.wait()，notify()是属于Object内的方法。
典型模式：生产者不断生产商品，消费者不断消费商品。
public static void main(String[] args) {
Product product = new Product();
new Thread(new Producer(product)).start();
new Thread(new Consumer(product)).start();
}
// 产品类
class Product {
private String name;
private double price;
// 产品是否生产的标志，默认没有生产完成
boolean flag = false;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
public boolean isFlag() {
return flag;
}
public void setFlag(boolean flag) {
this.flag = flag;
}
}
//生产者
class Producer implements Runnable {
private Product mProduct;
public Producer(Product product) {
mProduct = product;
}
@Override
public void run() {
int i = 0;
while (true) {
synchronized (mProduct) {
if (mProduct.isFlag() == false) {
if (i % 2 == 0) {
mProduct.setName("苹果");
mProduct.setPrice(10.5);
} else {
mProduct.setName("樱桃");
mProduct.setPrice(20.5);
}
i++;
System.out.println("生产者：生产了："
+ mProduct.getName()
+ "价格为："
+ mProduct.getPrice());
mProduct.setFlag(true);
mProduct.notify(); //唤醒消费者消费
} else {
try {
mProduct.wait();// 已经生产完毕，等待消费
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
}
//消费者
class Consumer implements Runnable {
private Product mProduct;
public Consumer(Product product) {
mProduct = product;
}
@Override
public void run() {
while (true) {
synchronized (mProduct) {
if (mProduct.isFlag() == true) {
System.out.println("消费者：消费了："
+ mProduct.getName()
+ "价格为："
+ mProduct.getPrice());
mProduct.setFlag(false);
mProduct.notify();
}else{
try {
mProduct.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
}
2.使用 Lock、Condition 实现线程通信
public static final ReentrantLock LOCK = new ReentrantLock();
public static final Condition CONDITION = LOCK.newCondition();
ReentrantLock：用来解决线程安全问题
Condition：用来实现线程通信
CONDITION.signalAll()：唤醒等待线程
CONDITION.await()：使线程等待
// 产品类
class Product {
private String name;
private double price;
// 产品是否生产的标志，默认没有生产完成
boolean flag = false;
public static final ReentrantLock LOCK = new ReentrantLock();
public static final Condition CONDITION = LOCK.newCondition();
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
public boolean isFlag() {
return flag;
}
public void setFlag(boolean flag) {
this.flag = flag;
}
}
//生产者
class Producer implements Runnable {
private Product mProduct;
public Producer(Product product) {
mProduct = product;
}
@Override
public void run() {
int i = 0;
while (true) {
Product.LOCK.lock();
try {
if (mProduct.isFlag() == false) {
if (i % 2 == 0) {
mProduct.setName("苹果");
mProduct.setPrice(10.5);
} else {
mProduct.setName("樱桃");
mProduct.setPrice(20.5);
}
i++;
System.out.println("生产者：生产了："
+ mProduct.getName()
+ "价格为："
+ mProduct.getPrice());
mProduct.setFlag(true);
Product.CONDITION.signalAll();
} else {
Product.CONDITION.await();
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
Product.LOCK.unlock();
}
}
}
}
//消费者
class Consumer implements Runnable {
private Product mProduct;
public Consumer(Product product) {
mProduct = product;
}
@Override
public void run() {
while (true) {
Product.LOCK.lock();
try {
if (mProduct.isFlag() == true) {
System.out.println("消费者：消费了："
+ mProduct.getName()
+ "价格为："
+ mProduct.getPrice());
mProduct.setFlag(false);
Product.CONDITION.signalAll();
} else {
Product.CONDITION.await();
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
Product.LOCK.unlock();
}
}
}
}
线程停止，礼让，守护
线程停止
1.一般线程都存在循环，通过控制其循环条件的变量来停止线程。
2.如果线程做了相应的wait()，就需要调用notify()或interrupt()来停止。
3.interrupt()会中断线程，同时清除线程临时堵塞状态。
4.interrupt()会抛出一个InterruptedException异常，相当于强制停止线程。
public static void main(String[] args) {
Demo demo = new Demo();
Thread thread = new Thread(demo);
thread.start();
new Timer().schedule(new TimerTask() {
@Override
public void run() {
demo.flag = false;
demo.interrupt();
}
}, 3000);
}
class Demo extends Thread {
public boolean flag = true;
@Override
public void run() {
while (flag) {
System.out.println("Test");
}
}
}
线程礼让
join()
1.线程如果执行join()，就意味着有新线程加入。
2.执行join()的线程必须要让步给新加入的线程，等新线程完成任务后才能继续执行。
yield()
表示当前线程对象提示调度器自己愿意让出CPU资源，但是调度器可以自由忽略该提示。
线程守护
isDaemon()：判断一个线程是否为守护线程。
setDaemon(boolean on)：设置一个线程为守护线程。
注意
1.守护线程依存于主线程，主线程消亡，守护线程消亡。
2.在一个进程中如果只剩下了守护线程，那么守护线程也会死亡。
3.线程默认都不是守护线程。
