java多线程
java多线程
进程、线程与多线程
-
进程是执行程序的一次执行过程，是一个动态的概念，是系统支援分配的单位
-
通常一个进程可以包含一个或多个线程。线程是CPU调度和执行的单位
-
线程就是独立执行的路径，由cpu调度
-
线程会带来额外的开销，如cpu调度时间，并发控制开销
-
每个线程在自己的工作内存中交互，内存控制不当会造成数据的不一致
-
main()称之为主线程，为系统的入口，用于执行整个程序
-
程序运行时，即使没有自己创建线程，后台也会有多个线程如主线程，gc线程
-
很多线程是模拟出来的，真正的多线程是指有多个cpu，即多核，如服务器。如果是模拟出来的多线程，即只有一个cpu的情况下，在同一个时间点，cpu只能执行一个代码，因为切换的很快，所以有了同时执行的错觉
线程的三种创建方式
- Thread class：继承Thread类
- Runnable接口：实现Runnable接口
- Callable接口：实现Callable接口
通过继承Thread创建线程
注意：Thread类实现了Runnable接口
流程：
1. 自定义线程类继承Thread类
2. 重写其run()方法，编写程序执行体
3. 创建线程对象，调用start()方法启动线程
public class MyThread extends Thread {
@Override
public void run() {
//run方法线程体
for (int i = 0; i < 5; i++) {
System.out.println("run方法线程--"+i);
}
}
public static void main(String[] args) {
//run方法线程
MyThread myThread = new MyThread();
//启动线程，另外线程只能启动一次死亡之后不能重新启动
myThread.start();
//主线程
for (int i = 0; i < 5; i++) {
System.out.println("主线程--"+i);
}
}
}
/*out:
主线程--0
run方法线程--0
主线程--1
run方法线程--1
主线程--2
run方法线程--2
主线程--3
run方法线程--3
主线程--4
run方法线程--4
注意：输出结果不唯一，每次执行结果不一样
线程开启不一定立即执行，是由cpu调度执行
实现Runnable接口创建线程
1. 自定义线程类实现Runnable接口
2. 重写其run()方法，编写程序执行体
3. 创建该实现类对象，创建Thread线程对象(或者创建Thread对象)，并且向Thread对象丢入Runnable实现类(代理方法)
public class MyThread implements Runnable {
@Override
public void run() {
//run方法线程体
for (int i = 0; i < 5; i++) {
System.out.println("run方法线程--"+i);
}
}
public static void main(String[] args) {
//run方法线程
MyThread myThread = new MyThread();
//静态代理
new Thread(myThread).start();
//主线程
for (int i = 0; i < 5; i++) {
System.out.println("主线程--"+i);
}
}
}
/*
主线程--0
run方法线程--0
主线程--1
run方法线程--1
主线程--2
主线程--3
run方法线程--2
主线程--4
run方法线程--3
run方法线程--4
相比于前一种更推荐本方法：避免单继承局限，灵活方便，方便一个对象被多个线程使用
例如：
public class MyThread implements Runnable {
private int number=10;
@Override
public void run() {
while (true){
if(number<=0){
break;
}
//线程休眠，防止cpu速度太快瞬间把票抢完
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
//当前线程名字
System.out.println(Thread.currentThread().getName()+"--"+number--);
}
}
public static void main(String[] args) {
//run方法线程
MyThread myThread = new MyThread();
//第二个参数为线程名字
new Thread(myThread,"李").start();
new Thread(myThread,"马").start();
new Thread(myThread,"王").start();
}
}
/*
马--9
王--10
李--10
马--8
李--8
王--8
马--7
王--6
李--6
王--5
马--4
李--3
李--0
马--2
王--1
注意：至于为什么出现两个人得到同一个数字，或者出现0，则是一些经典的线程同步问题
实现Callable接口创建线程
步骤：
- 实现Callable接口，需要返回值类型
- 重写call方法，需要抛出异常
- 创建目标对象
- 创建执行服务
- 提交执行
- 获取结果
- 关闭服务
//<>中填写返回值类型（下面call方法的返回值）
public class MyThread implements Callable<Boolean> {
//重写call方法，返回值保持和<>中的一样
@Override
public Boolean call() throws Exception {\
//具体线程操作写在这里
return false;
}
public static void main(String[] args) throws ExecutionException, InterruptedException {
MyThread myThread1 = new MyThread();
MyThread myThread2 = new MyThread();
MyThread myThread3 = new MyThread();
//创建执行服务:newFixedThreadPool线程池，参数为线程池大小
ExecutorService ser = Executors.newFixedThreadPool(3);
//提交执行:<>中类型就是call的返回类型
Future<Boolean> r1 = ser.submit(myThread1);
Future<Boolean> r2 = ser.submit(myThread2);
Future<Boolean> r3 = ser.submit(myThread3);
//获取结果:call()返回值
Boolean rs1 = r1.get();
Boolean rs2 = r2.get();
Boolean rs3 = r3.get();
//关闭服务
ser.shutdownNow();
}
}
好处：
-
可以定义返回值
-
可以抛出异常
静态代理
代理就是两个对象实现同一个接口，一个是代理对象一个是真实对象，通过代理对象执行真实对象方法。具体方法：代理对象和真实对象实现同一个接口，创建代理对象同时向其中传入一个真实对象，在代理对象中操作真实对象，在外部调用操作代理对象就能够操作真实对象。
例如前面通过实现Runnable接口创建线程就运用了静态代理
//MyThread是Runnable接口的实现类
MyThread myThread = new MyThread();
//静态代理
new Thread(myThread).start();
好处：
- 代理对象可以在真实对象基础上做很多拓展
- 真实对象专注于自己，专注于核心方法
Lambda表达式
为什么使用它？
- 避免匿名内部类过多
- 让代码看起来更加简洁
- 去掉无意义代码留下核心逻辑
函数式接口
- 理解函数式接口是学习Lambda表达式的关机
- 函数式接口的定义：
- 任何接口，如果只包含唯一一个抽象方法，那么它就是函数式接口
- 对于函数式接口，我们可以通过lamda表达式来创建该接口的对象
怎么使用？
public interface MyInterface {
void lambda();
}
class main {
public static void main(String[] args) {
// 无参且一行
MyInterface myInterface =() -> System.out.println("hello world");
// 有参数a
// MyInterface myInterface =a -> System.out.println("hello world");
// 多行
// MyInterface myInterface1 = ()->{
// System.out.println();
// System.out.println()
// };
// 上述代码完全类似下面的匿名内部类
// MyInterface myInterface1 = new MyInterface() {
// @Override
// public void lambda() {
// System.out.println("hello world");
// }
// };
}
}
//out:hello world
线程的五大状态
线程方法
停止线程
- 可以但不推荐使用JDK提供的stop()、destroy()方法，已经废弃
- 推荐线程自己停下来
- 建议使用一个标志位进行终止变量，当flag=false终止线程运行
public class MyThread implements Runnable {
private boolean flag = true;
@Override
public void run() {
int i = 0;
while (flag){
System.out.println("run........Thread"+i++);
}
}
public void stop(){
this.flag = false;
System.out.println("线程已经停止");
}
public static void main(String[] args) {
MyThread myThread = new MyThread();
new Thread(myThread).start();
for (int i = 0; i < 10; i++) {
//不加这一句的话循环速度太快以至于线程还没运行
System.out.println("main---"+i);
if(i==5){
//调用自己写的stop方法
myThread.stop();
}
}
}
}
/*
main---0
run........Thread0
main---1
run........Thread1
main---2
run........Thread2
main---3
run........Thread3
main---4
run........Thread4
main---5
run........Thread5
线程已经停止
main---6
main---7
main---8
main---9
线程休眠
- sleep()指定当前线程阻塞的毫秒数
- 运行状态转为阻塞状态
- sleep存在异常InterruptedException
- sleep时间到达后进入就绪状态
- 其可以模拟网络延时，倒计时等
- 每一个对象都有一个锁，sleep不会释放锁
没啥可说的固定写法：Thread.sleep()
线程礼让
- 即让当前正在执行的线程暂停，但不阻塞
- 把线程从运行转为就绪状态
- 让cpu重新调度，礼让不一定成功，看cpu心情
- 固定写法：Thread.yield();
public class MyThread implements Runnable {
private boolean flag = true;
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"开始执行");
Thread.yield();
System.out.println(Thread.currentThread().getName()+"完成执行");
}
public static void main(String[] args) {
MyThread myThread = new MyThread();
MyThread myThread1 = new MyThread();
new Thread(myThread,"a").start();
new Thread(myThread1,"b").start();
}
}
/*
a开始执行
b开始执行
b完成执行
a完成执行
线程强制执行
- Join合并线程，待此线程完成后，才去执行其他线程
- 可以看作插队
public class MyThread implements Runnable {
@Override
public void run() {
for (int i = 0; i < 5; i++) {
System.out.println("VIP驾到通通闪开！"+i);
}
}
public static void main(String[] args) throws InterruptedException {
MyThread myThread1 = new MyThread();
Thread thread1 = new Thread(myThread1, "vip");
//主线程
for (int i = 0; i < 10; i++) {
if(i==5){
thread1.start();
thread1.join();
}
System.out.println("我是一个主线程"+i);
}
}
}
/*
我是一个主线程0
我是一个主线程1
我是一个主线程2
我是一个主线程3
我是一个主线程4
VIP驾到通通闪开！0
VIP驾到通通闪开！1
VIP驾到通通闪开！2
VIP驾到通通闪开！3
VIP驾到通通闪开！4
我是一个主线程5
我是一个主线程6
我是一个主线程7
我是一个主线程8
我是一个主线程9
线程状态观测
public static void main(String[] args) throws InterruptedException {
Thread thread = new Thread(() -> {
for (int i = 0; i < 5; i++) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("////////");
});
//观测状态
Thread.State state = thread.getState();
System.out.println(state);
// 启动线程
thread.start();
state = thread.getState();
System.out.println(state);
// 只要线程不终止一直输出状态
while (state != Thread.State.TERMINATED){
Thread.sleep(1000);
state = thread.getState();
System.out.println(state);
}
}
/*
NEW
RUNNABLE
RUNNABLE
TIMED_WAITING
TIMED_WAITING
RUNNABLE
TIMED_WAITING
////////
TERMINATED
线程优先级
-
线程优先级用数字表示：Thread.MIN_PRIORITY=1;
Thread.MAX_PRIORITY = 10;
Thread.NORM_PRIORITY = 5;
上面为最小最大正常优先级，均为常量
-
可以使用以下方式改变或者获取优先级：
1. .getPrioriyt
1. .setPriority(int xxx) -
另外，优先级高并不是一定先执行，而是相对来说权重更高，到底先还是后看cpu调度
public class MyThread implements Runnable {
@Override
public void run() {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName());
}
public static void main(String[] args) throws InterruptedException {
//主线程优先级:主线程优先级无法修改
System.out.println(Thread.currentThread().getName()+"-----"+Thread.currentThread().getPriority());
MyThread myThread = new MyThread();
Thread t1 = new Thread(myThread,"t1");
Thread t2 = new Thread(myThread,"t2");
Thread t3 = new Thread(myThread,"t3");
Thread t4 = new Thread(myThread,"t4");
Thread t5 = new Thread(myThread,"t5");
// 一定要注意：先设置优先级再启动否则没用
t1.start();
t2.setPriority(1);
t2.start();
//设置为最大优先级
t3.setPriority(Thread.MAX_PRIORITY);
t3.start();
}
}
/*
main-----5
t3
t2
t1
守护线程
- daemon
- 线程分为用户线程和守护线程
- 虚拟机必须确保用户线程执行完毕
- 虚拟机不用等待守护线程完毕
- 守护线程如后台记录操作日志、监控内存、垃圾回收等待
- 守护线程：字面意思守护用户线程，虚拟机无视是否还有守护线程存在，当用户线程结束时虚拟机关闭
Thread thread = new Thread();
//默认是false代表用户线程，设置为true表示守护线程
thread.setDaemon(true);
线程同步
-
就是多个线程操作同一个资源
-
线程同步其实就是一个等待机制，多个需要同时访问对象的线程进入对象等待池形成队列
-
并发：同一个对象被多个线程操作。如买票
-
队列和锁保障线程安全性
-
为了保证数据在方法中被访问时的正确性，在访问时加入锁机制synchronized
-
与此同时当一个线程获得对象的排它锁，独占资源，其他线程必须等待使用后释放锁即可，可能存在以下问题：
线程同步操作多种不安全问题，具体可以看上面实现Runnable接口创建线程的例子
synchronized（锁）
-
针对上面所说的问题：我们可以用锁来解决，即synchronized关键字，它包括方法和块两大用法
-
同步方法，synchronized方法控制对“对象”的访问，每个对象对应一把锁。每个synchronized方法都必须获得调用该方法的对象的锁才能执行，否则阻塞，方法一旦执行就会独占该锁，直到该方法返回。缺陷：若将一个大方法申明为synchronized将会影响效率
-
同步块：synchronized(obj){} obj称之为同步监视器，其可以是任何对象，但是推荐共享资源作为同步监视器。另外同步方法不用同步监视器因为其同步监视器就是this，就是这个对象本身，或者class
-
同步监视器执行过程：
1. 第一个线程访问，锁定同步监视器
2. 第二个线程访问，发现已经被锁定，无法访问
3. 第一个线程访问完毕，解锁同步监视器
4. 第二个线程访问，发现同步监视器没有锁，然后锁定并且访问
使用同步方法解决问题：
public class MyThread implements Runnable {
private int number=10;
private boolean flag = true;
@Override
public void run() {
while (flag) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
buy();
}
}
//上锁，run方法也可以锁
public synchronized void buy() {
if (number < 1) {
flag=false;
return;
}
System.out.println(Thread.currentThread().getName() + "--" + number--);
}
public static void main(String[] args) {
MyThread myThread = new MyThread();
new Thread(myThread,"李").start();
new Thread(myThread,"马").start();
new Thread(myThread,"王").start();
}
}
/*
李--10
王--9
马--8
马--7
李--6
王--5
马--4
李--3
王--2
马--1
锁块：
public class MyThread implements Runnable {
private int number=10;
private boolean flag = true;
@Override
public void run() {
while (flag) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//同步块，（）填变化的量必须是引用类型，锁定的就是传入参数
synchronized (Integer.valueOf(number)){
if (number < 1) {
flag=false;
}
else {
System.out.println(Thread.currentThread().getName() + "--" + number--);
}
}
}
}
public static void main(String[] args) {
MyThread myThread = new MyThread();
new Thread(myThread,"李").start();
new Thread(myThread,"马").start();
new Thread(myThread,"王").start();
}
}
/*
马--10
王--9
李--8
李--7
王--6
马--5
马--4
李--3
王--2
马--1
CopyOnWriteArrayList
//线程安全的arraylist
CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();
for (int i = 0; i < 1000; i++) {
new Thread(()->{
list.add(Thread.currentThread().getName());
}).start();
}
Thread.sleep(3000);
System.out.println(list.size());
//1000
死锁
多个线程各自占有一些共享资源，同时互相等待对方占有资源，从而导致两个或多个线程都在等待对方释放资源停止执行的情况。
某一个同步块同时拥有两个以上对象的锁，就可能出现死锁
//当mirror和lipstick都只有一份时
//获得mirror
synchronized (mirror){
// 获得了mirror，此时lipstick被另外一个线程占据等待
// 其释放，与此同时占据lipstick的线程也在等待它释放mirror
// 于是死锁发生了
synchronized (lipstick){
}
}
产生死锁的必要条件
Lock（锁）
- JDK5.0开始，java提供更加强大的线程同步机制--通过显式定义同步锁对象来实现同步。同步锁使用Lock充当
- 每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应当先获得Lock锁
- ReentranLock类实现了Lock，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock,可以显式加锁、释放锁
public class MyThread implements Runnable {
private static Integer number=10;
private boolean flag = true;
//定义lock锁
private final ReentrantLock lock = new ReentrantLock();
@Override
public void run() {
while (flag) {
try {
Thread.sleep(100);
lock.lock();//加锁，上锁区域就是lock到unlock区域
if (number < 1) {
flag=false;
}
else {
System.out.println(Thread.currentThread().getName() + "--" +number--);
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
//解锁
lock.unlock();
}
}
}
public static void main(String[] args) {
MyThread myThread = new MyThread();
new Thread(myThread,"李").start();
new Thread(myThread,"马").start();
new Thread(myThread,"王").start();
}
}
/*
马--10
王--9
李--8
李--7
王--6
马--5
王--4
李--3
马--2
马--1
线程协作--生产者消费者问题
生产者消费者问题：生产者消费者共享一个资源，并且生产者和消费者之间相互依赖，互为条件，操作系统学过的不想多说具体如下：
下面两个解决办法后面有具体演示
解决方法1：
解决方法二：信号灯法
java提供了几个方法解决线程之间的通信问题：
注意：以下均是Object类的方法，都只能在同步方法或者同步代码块中使用，否则会抛出异常，另外sleep不会释放锁，wait会释放锁
解决方法一：管程法
public class Test {
public static void main(String[] args) {
SynContainer container = new SynContainer();
new Producer(container).start();
new Consumer().start();
}
}
//生产者
class Producer extends Thread{
//缓冲区
static SynContainer container;
public Producer(SynContainer container) {
this.container = container;
}
@Override
public void run() {
for (int i = 0; i < 5; i++) {
container.push(new Chicken(i));
System.out.println("生产了第"+i+"只鸡");
}
}
}
//消费者
class Consumer extends Thread{
@Override
public void run() {
for (int i = 0; i < 5; i++) {
System.out.println("消费了第"+ Producer.container.pop().id+"只鸡");
}
}
}
//产品
class Chicken{
int id;
public Chicken(int id) {
this.id = id;
}
}
//缓冲区
class SynContainer{
//需要一个容器大小
Chicken[] chickens = new Chicken[10];
// 容器计数器
int count = 0;
//生产者放入产品
public synchronized void push(Chicken chicken){
//如果容器满了，等待消费者消费
if(count==chickens.length){
//通知消费者消费，生成等待
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}else {
//如果没有满，我们就需要丢入产品
chickens[count] = chicken;
count++;
}
// 通知消费者可以消费了
this.notifyAll();
}
//消费者消费产品
public synchronized Chicken pop() {
//判断是否有产品
if(count==0){
// 等待生产者生产
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
// 存在产品开始消费
count--;
Chicken chicken = chickens[count];
// 吃完了通知生产者生产
this.notifyAll();
return chicken;
}
}
/*
生产了第0只鸡
消费了第0只鸡
生产了第1只鸡
生产了第2只鸡
消费了第1只鸡
生产了第3只鸡
消费了第3只鸡
生产了第4只鸡
消费了第4只鸡
消费了第2只鸡
上面实现的存在一定问题，但是要传达的思想就这样
解决方法二：信号灯法
public class Test {
public static void main(String[] args) {
TV tv =new TV();
new Player(tv).start();
new Watcher(tv).start();
}
}
//生产者
class Player extends Thread{
TV tv;
public Player(TV tv) {
this.tv = tv;
}
@Override
public void run() {
for (int i = 0; i < 5; i++) {
if(i%2==0){
this.tv.play("x节目播放中");
}
else {
this.tv.play("y节目播放中");
}
}
}
}
//消费者
class Watcher extends Thread{
TV tv;
public Watcher(TV tv) {
this.tv = tv;
}
@Override
public void run() {
for (int i = 0; i < 5; i++) {
tv.watch();
}
}
}
//产品
class TV{
//演员表演，观众等待 T
//观众观看，演员表演 F
String voice;//表演的节目
boolean flag = true;
public synchronized void play(String voice){
if(!flag){
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("演员表演了:"+voice);
this.notifyAll();
this.voice = voice;
this.flag = !this.flag;
}
public synchronized void watch(){
if(flag) {
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("观看了"+voice);
// 通知演员表演
this.notifyAll();
this.flag = !this.flag;
}
}
/*
演员表演了:x节目播放中
观看了x节目播放中
演员表演了:y节目播放中
观看了y节目播放中
演员表演了:x节目播放中
观看了x节目播放中
演员表演了:y节目播放中
观看了y节目播放中
演员表演了:x节目播放中
观看了x节目播放中
线程池
-
经常创建和销毁、使用量大的资源，对性能影响很大
-
思路：提前创建好多个线程，放入线程池，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用。
-
好处：
- 提高响应速度
- 降低资源消耗
- 便于线程管理
- corePoolSize：核心池大小
- maximumPoolSize：最大线程数
- keepAliveTime：线程没有任务时最多保持多少时间后终结
-
相关api：
- ExecutorService ：真正的线程池接口。常见子类ThreadPoolExecutor
- 相关方法：
- 相关方法：
- ExecutorService ：真正的线程池接口。常见子类ThreadPoolExecutor
-
Executors：工具类，用于创建并返回不同类型的线程池
public class MyThread implements Runnable {
private int number=10;
private boolean flag = true;
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName());
}
}
public static void main(String[] args) {
//创建线程池，参数为大小
ExecutorService service = Executors.newFixedThreadPool(10);
//执行
service.execute(new MyThread());
service.execute(new MyThread());
service.execute(new MyThread());
service.execute(new MyThread());
service.execute(new MyThread());
// 关闭链接
service.shutdownNow();
}
}
/*
pool-1-thread-1
pool-1-thread-1
pool-1-thread-1
pool-1-thread-1
pool-1-thread-1
pool-1-thread-1
pool-1-thread-1
pool-1-thread-1
pool-1-thread-1
pool-1-thread-1
pool-1-thread-2
pool-1-thread-2
pool-1-thread-2
pool-1-thread-2
pool-1-thread-2
pool-1-thread-2
pool-1-thread-2
pool-1-thread-2
pool-1-thread-2
pool-1-thread-2
pool-1-thread-5
pool-1-thread-5
pool-1-thread-5
pool-1-thread-5
pool-1-thread-5
pool-1-thread-5
pool-1-thread-5
pool-1-thread-5
pool-1-thread-5
pool-1-thread-5
pool-1-thread-4
pool-1-thread-4
pool-1-thread-4
pool-1-thread-4
pool-1-thread-4
pool-1-thread-4
pool-1-thread-4
pool-1-thread-4
pool-1-thread-4
pool-1-thread-4
pool-1-thread-3
pool-1-thread-3
pool-1-thread-3
pool-1-thread-3
pool-1-thread-3
pool-1-thread-3
pool-1-thread-3
pool-1-thread-3
pool-1-thread-3
pool-1-thread-3