Java多线程基础

最新推荐文章于 2024-10-05 12:07:50 发布

MoRis._

最新推荐文章于 2024-10-05 12:07:50 发布

阅读量84

点赞数

文章标签： java

本文链接：https://blog.csdn.net/qq_30038621/article/details/120044720

版权

Java 专栏收录该内容

8 篇文章 0 订阅

订阅专栏

本文详细讲解了线程的基本概念，包括线程创建、状态及其方法，重点讨论了线程同步、线程协作（如生产者消费者模式）和锁的使用（synchronized与Lock对比）。通过实例演示了守护线程、睡眠与礼让、Join方法，以及避免死锁的策略。

摘要由CSDN通过智能技术生成

Thead

基本概念

线程就是独立的执行路径
在程序运行时，即使没有自己创线程，后台也会有多个线程
main()称之为主线程，为系统的入口，用于执行整个程序
在一个进程中，如果开辟了多个线程，线程的运行由调度器安排，调度器是与操作系统紧密相关的，先后顺序是不能人为干预的
对同一份资源操作时，会存在资源抢占的问题，需要加入并发控制
线程会带来额外的开销，入cpu的时间，并发控制开销
每个线程在自己的工作内存交互，内存控制不当会造成数据不一致

线程创建方式

继承Thead类

package com.Weirdo.demo01;

import org.apache.commons.io.FileUtils;

import java.io.File;
import java.io.IOException;
import java.net.URL;

/**
 * 实现多线程同步下载图片
 */
public class DemoThead02 extends Thread{

    private String url;
    private String name;

    public DemoThead02(String url,String name){
        this.url = url;
        this.name = name;

    }

    //线程的执行体
    @Override
    public void run() {
        webDownloader webDownloader = new webDownloader();
        webDownloader.downloader(url,name);
        System.out.println("图片的名字为：" + name);
    }

    public static void main(String[] args) {
        DemoThead02 t1 = new DemoThead02("https://img-blog.csdnimg.cn/20210628100104811.png","t1.png");
        DemoThead02 t2 = new DemoThead02("https://img-blog.csdnimg.cn/20210628100104811.png","t2.png");
        DemoThead02 t3 = new DemoThead02("https://img-blog.csdnimg.cn/20210628100104811.png","t3.png");
        t1.start();
        t2.start();
        t3.start();

    }
}



//下载器
class webDownloader{
    public void downloader(String url,String name) {
        try {
            FileUtils.copyURLToFile(new URL(url),new File(name));
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("downloader方法IO异常");
        }
    }
}

实现Runnable接口

package com.Weirdo.demo01;

/**
 * 实现多个线程操作一个对象
 */
public class DemoThread03 implements Runnable{

    private int tick = 10;
    @Override
    public void run() {

        while (true) {

            if (tick <= 0){
                break;
            }
            System.out.println(Thread.currentThread().getName() + "拿到了第" + tick-- + "个数");
        }
    }

    public static void main(String[] args) {
        DemoThread03 demoThread03 = new DemoThread03();
        new Thread(demoThread03,"tick1").start();
        new Thread(demoThread03,"tick2").start();
        new Thread(demoThread03,"tick3").start();
    }
}

实现callable接口
- 需要返回值类型
- 重新call方法，需要抛出异常
- 创建目标对象
- 创建执行服务：ExecutorService ser = Executors.newFixedThreadPool(1)
- 提交执行: Future result = ser.submit(t1)
- 获取结果: boolean r1 = result.get()
- 关闭服务: ser.shutdownNow()

Lamda表达式

作用：

避免匿名内部类定义过多

可以让代码看起来很简洁

去掉没有意义的代码，只留下核心逻辑

函数式接口的定义

任何接口，如果只包含一个唯一的抽象方法，那么他就是一个函数式接口

函数接口可以通过Lambda表达式来创建该接口的对象

总结：

Lambda表达式只能有一行的情况下才能简化为一行

必须是函数式接口

多个参数也可以去掉参数类型

线程状态

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BQjngrF5-1630488042971)(C:\Users\admin\AppData\Roaming\Typora\typora-user-images\image-20210831160334041.png)]

创建状态
就绪状态
阻塞状态
运行状态
死亡状态

线程方法

setPriority(int newPriority)：更改线程的优先级
static void sleep(long millis)：在指定的毫秒数内让当前正在执行的线程休眠
void join()：等待该线程终止
static void yield()：暂停当前正在执行的线程对象，并执行其他线程
void interrupt()：中断线程
boolean isAlive()：测试线程是否处于活动状态

线程休眠

sleep（时间）指定当前线程阻塞的毫秒数
sleep存在异常InterruptedException
sleep时间达到后线程进入就绪状态
sleep可以模拟网络延时，倒计时等
每一个对象都有一个锁，sleep不会释放锁

package com.Weirdo.demo02;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.logging.SimpleFormatter;

/**
 * 模拟倒计时和当前时间
 */
public class TestSleep {

    public static void main(String[] args) {
        try {
            tenDown();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        //获取当前时间
        Date nowTime = new Date(System.currentTimeMillis());
        while (true){
            try {
                Thread.sleep(1000);
                System.out.println(new SimpleDateFormat("HH:mm:ss").format(nowTime));
                nowTime = new Date(System.currentTimeMillis());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void tenDown() throws InterruptedException {
        int num = 10;
        while (true){
            Thread.sleep(1000);
            System.out.println(num--);
            if (num<=0){
                break;
            }
        }
    }
}

线程礼让Yield

礼让线程，让当前正在执行的线程暂停，但不阻塞
将线程从运行状态转为就绪状态，让CPU重新调度

package com.Weirdo.demo02;

/**
 * 测试礼让线程
 * 礼让不一定成功
 */
public class TestYield {
    public static void main(String[] args) {
        Yield yield = new Yield();
        new Thread(yield,"a").start();
        new Thread(yield,"b").start();
    }
}

class Yield implements Runnable {

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "线程开始执行");
        Thread.yield();
        System.out.println(Thread.currentThread().getName() + "线程停止执行");
    }
}

Join

Join合并线程，待此线程执行完成之后，在执行其他线程，其他线程阻塞

package com.Weirdo.demo02;

public class TestJoin implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("线程VIP");
        }
    }

    public static void main(String[] args) throws InterruptedException {

        //启动线程
        TestJoin testJoin = new TestJoin();
        Thread thread = new Thread(testJoin);
        thread.start();

        //主线程
        for (int i = 0; i < 1000; i++) {
            if (i == 200){
                thread.join();
            }
        }
    }
}

线程状态

NEW：尚未启动的线程处于此状态
RUNNABLE：在java虚拟机中执行的的线程处于此状态
BLOCKED：被阻塞等待监视器锁定的线程处于此状态
WATTING：正在等待另一个线程执行特定动作的线程处于此状态
TIMED_WAITTING：正在等待另一个线程执行动作达到指定等待时间的线程处于此状态
TERMINAED：已退出的线程处于此状态

package com.Weirdo.demo02;

public class TestState {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(()->{
            for (int i = 0; i < 10; 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(100);
            state = thread.getState();
            System.out.println(state);
        }
    }
}

守护线程

线程分为用户线程和守护线程
虚拟机必须缺包用户线程执行完毕
虚拟机不用等待守护线程执行完毕
如后台记录操作日志，监控内存，垃圾回收等待

package com.Weirdo.demo02;

/**
 * 守护线程
 */
public class TestDaemon {
    public static void main(String[] args) {
        God god = new God();
        You you = new You();

        Thread thread = new Thread(god);

        thread.setDaemon(true);
        thread.start();

        new Thread(new You()).start();
    }
}

class God implements Runnable{
    @Override
    public void run() {
        while (true){
            System.out.println("god is Happy");
        }
    }
}

class You implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 36500; i++) {
            System.out.println("Happy");
        }
        System.out.println("bye");
    }
}

线程同步

由于同意进程的多个线程共享同一块存储空间，为了保证数据在方法中被访问时的正确性，在访问时加入锁机制（synchronized），当一个线程获得对象的排它锁，独占资源，其他线程必须等待，使用后释放锁即可
一个线程持有锁会导致其他所有需要此锁的线程挂起
在多线程竞争下，枷锁，释放锁会导致比较多的上下文切换和调度延迟，引起性能问题
如果一个优先级高的线程等待一个优先级的线程释放锁，会导致优先级导致，引起性能问题

synchronized (obj){
    
}

死锁

避免方法

互斥条件：一个资源每次只能被一个进程使用
请求与保持条件：一个进程因请求资源而被阻塞时，对已获得的资源保持不放
不剥夺条件：进程已获得的资源，在未使用完之前，不能强行剥夺
循环等待条件：若干进程直接形成一种头尾相接的循环等待资源

synchronized与Lock的对比

Lock是显示锁（手动开启和关闭锁，），synchronized是隐式锁，出了作用域会自动释放
Lock只有代码块锁，synchronized有代码块锁和方法锁
使用Lock锁，JVM将花费较少的时间来调度线程，性能更好，并且具有更好的扩展性（提供更多的子类）
优先使用顺序：
Lock > 同步代码块（已经进入了方法体，分配了相应资源） > 同步方法（在方法体之外）

线程协作

生产者消费者模式

线程通信方法

wait():表示线程一直等待，直到其他线程通知，与sleep不同，会释放锁
wait(long timeout):指定等待的毫秒数
notify():唤醒一个等待状态的线程
notifyAll():唤醒同一个对象上所有调用wait()方法的线程，优先级别高的线程，优先调度

synchronized与Lock的对比

Lock是显示锁（手动开启和关闭锁，），synchronized是隐式锁，出了作用域会自动释放
Lock只有代码块锁，synchronized有代码块锁和方法锁
使用Lock锁，JVM将花费较少的时间来调度线程，性能更好，并且具有更好的扩展性（提供更多的子类）
优先使用顺序：
Lock > 同步代码块（已经进入了方法体，分配了相应资源） > 同步方法（在方法体之外）