Java多线程基础

于 2022-08-19 18:38:28 发布
阅读量208 收藏
点赞数
分类专栏： 学习笔记 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_61931988/article/details/126324132
版权

一.进程，线程

1.什么是进程，线程

        进程（Process）是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。进程是线程的容器。程序是指令、数据及其组织形式的描述，进程是程序的实体。

        线程（Thread）是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。

2.怎么创建线程

2.1 继承Thread类

/**
 * 创建线程一：继承Thread类,重写run方法
 */
public class CreateThreadOne extends Thread{

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

    public static void main(String[] args) {
        //创建线程
        CreateThreadOne createThreadOne = new CreateThreadOne();
        /**
         * createThreadOne.run()  ：先执行run()方法的内容然后返回到主线程执行,同步执行
         * createThreadOne.start()：异步执行
         */
        //createThreadOne.run();
        createThreadOne.start();

        for (int i = 0; i < 2000; i++) {
            System.out.println("这是主线程"+i);
        }
    }
}

2.2 实现Runnable接口

public class CreateThreadTwo implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println("这是子线程=========="+i);
        }
    }

    public static void main(String[] args) {
        CreateThreadTwo createThreadTwo = new CreateThreadTwo();
//        createThreadTwo.run();
        new Thread(createThreadTwo).start();
        for (int i = 0; i < 1000; i++) {
            System.out.println("这是主线程"+i);
        }
    }
}

2.3 实现Callable接口，重写call方法

public class CreateThreadThree implements Callable<Boolean> {
    @Override
    public Boolean call() throws Exception {
        for (int i = 0; i < 200; i++) {
            System.out.println("ThreadName:"+Thread.currentThread().getName()+",i="+i);
        }
        return true;
    }

    public static void main(String[] args) {
        CreateThreadThree ctt1 = new CreateThreadThree();
        CreateThreadThree ctt2 = new CreateThreadThree();
        CreateThreadThree ctt3 = new CreateThreadThree();

        //1.创建服务
        ExecutorService executorService = Executors.newFixedThreadPool(3);

        //2.提交执行
        Future<Boolean> future1 = executorService.submit(ctt1);
        Future<Boolean> future2 = executorService.submit(ctt2);
        Future<Boolean> future3 = executorService.submit(ctt3);

        //3.获取结果
        try {
            Boolean result1 = future1.get();
            Boolean result2 = future2.get();
            Boolean result3 = future3.get();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

        //4.关闭服务
        executorService.shutdownNow();
    }
}

3.Lambda表达式

3.1函数式接口：一个接口中只有一个抽象方法的接口叫函数式接口

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

四.线程的状态

4.1 线程的五大状态

 4.2 线程的停止，使用标志位停止线程

/**
 * jdk不推荐使用stop方法
 * 使用标志位来使线程停止
 */
public class TestStop implements Runnable{
    /**
     * 设置标志位,当flag=false时线程停止
     */
    private boolean flag = true;

    @Override
    public void run() {
        int i = 0;
        while (flag){
            System.out.println(Thread.currentThread().getName()+",i="+i+++"============");
        }
    }

    //结束线程的方法
    public void stop(){
        this.flag = false;
    }

    public static void main(String[] args) {
        TestStop testStop = new TestStop();
        new Thread(testStop,"testStop").start();

        for (int i = 0; i < 200; i++) {
            if (i==190){
                testStop.stop();
            }
            System.out.println("main,i="+i);
        }

    }
}

4.3 线程休眠_sleep作用

模拟网络延迟(放大问题的发生性)，倒计时

每一个对象都有一把锁，sleep不会释放锁

4.4线程礼让_yield作用

public class TestYield implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+",start");
        /**
         * 线程礼让,线程：运行态--->就绪态
         * 线程礼让可能不会成功，线程从运行-->就绪 然后直接得到CPU的调度
         */
        Thread.yield();
        System.out.println(Thread.currentThread().getName()+",end");
    }

    public static void main(String[] args) {
        TestYield testYield = new TestYield();
        new Thread(testYield,"T1").start();
        new Thread(testYield,"T2").start();
    }
}

4.5 线程等待_ join，调用join方法的线程先执行，其他线程等待被阻塞

public class TestJoin implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("子线程,i="+i+"=============");
        }
    }

    public static void main(String[] args) {
        TestJoin testJoin = new TestJoin();
        Thread thread = new Thread(testJoin);
        thread.start();
        for (int i = 0; i < 200; i++) {
            if (i == 100){
                try {
                    //当i为100时,让thread线程执行完,等待thread执行
                    thread.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("main方法,i="+i);
        }
    }
}

4.5线程的状态_State，线程只能启动一次

public class TestState {
    public static void main(String[] args) {
        Thread thread = new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    Thread.sleep(100);
                    System.out.println(Thread.currentThread().getName()+",i="+i);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        Thread.State state = thread.getState();
        System.out.println("=====执行start方法前的状态："+state);

        thread.start();
        state = thread.getState();
        System.out.println("=====执行start方法后的状态："+state);

        while (state != Thread.State.TERMINATED){
            System.out.println("=====执行start方法后的状态："+state+"======");
            try {
                Thread.sleep(150);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            state = thread.getState();
        }
        state = thread.getState();
        System.out.println("=====状态："+state);
    }
}

4.6 线程的优先级_priority
 

public class TestPriority implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());
    }

    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());
        TestPriority testPriority = new TestPriority();
        Thread t1 = new Thread(testPriority,"t1");
        Thread t2 = new Thread(testPriority,"t2");
        Thread t3 = new Thread(testPriority,"t3");
        Thread t4 = new Thread(testPriority,"t4");
        Thread t5 = new Thread(testPriority,"t5");

        /**
         * 1<=Priority<=10
         */
        t1.setPriority(Thread.MIN_PRIORITY);
        t1.start();

        t2.setPriority(3);
        t2.start();

        t3.setPriority(6);
        t3.start();

        t4.setPriority(1);
        t4.start();

        t5.setPriority(Thread.MAX_PRIORITY);
        t5.start();
    }
}

4.7守护线程_daemon

        线程分为用户线程和守护线程，当用户线程执行完，当前没有任何的用户线程执行，守护线程也就结束

public class TestDaemon {
    public static void main(String[] args) {
        I i = new I();
        God god = new God();
        Thread daemonThread = new Thread(god);
        //将当前线程设置为守护线程
        daemonThread.setDaemon(true);
        daemonThread.start();

        new Thread(i).start();
    }
}
class I implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("我活了"+i+"年");
        }
    }
}
class God implements Runnable{
    @Override
    public void run() {
        while (true){
            System.out.println("时间很快,又过了一年");
        }
    }
}

五.线程的同步

5.1 并发

        并发：同一个对象被多个线程同时操作

        银行取钱，买票等都涉及并发问题

        不安全的集合案例：线程安全问题

public class UnSafeCollection{
    public static void main(String[] args) {
        /**
         * 不安全的集合：ArrayList
         * 安全的：
         */
        List<String> unSafeColl = new ArrayList<>();
        List<String> safeColl = new Vector<>();

        for (int i = 0; i < 100; i++) {
            new Thread(()->{
                unSafeColl.add(Thread.currentThread().getName());
                safeColl.add(Thread.currentThread().getName());
            }).start();
        }
        System.out.println("unSafeColl size : "+unSafeColl.size());
        System.out.println("safeColl size : "+safeColl.size());
    }
}

运行结果：

 

5.2线程同步

5.2.1同步方法_synchronized

        线程在并发时(多个线程访问同一个对象)，出现了线程的不安全问题，例如买票

public class BuyTicket implements Runnable{
    public Integer ticketNubs = 10;
    public boolean exitBool = true;

    @Override
    public void run() {
        while (exitBool){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            this.buy();
        }
    }

    /**
     * synchronized修饰的方法就是线程同步方法
     * 不加synchronized会产生线程的不安全问题
     */
    private synchronized void buy(){
        if (ticketNubs > 0){
            System.out.println(Thread.currentThread().getName()+"买了1张票,还有"+ticketNubs--);
        }else if (ticketNubs <= 0){
            exitBool = false;
        }
    }

    public static void main(String[] args) {
        BuyTicket buyTicket = new BuyTicket();
        new Thread(buyTicket,"t1").start();
        new Thread(buyTicket,"t2").start();
        new Thread(buyTicket,"t3").start();
    }
}

运行结果：

5.2.2同步块

        进行同步的方法二：同步代码块

public class SynchronizedBlock {
    public static void main(String[] args) {
        List<String> unSafeList = new ArrayList();
        List<String> safeList = new Vector<>();
        for (int i = 0; i < 100; i++) {
            /**
             * 同步块
             * ()里面是要锁定的对象
             */
            new Thread(()->{
                synchronized (unSafeList){
                    unSafeList.add(Thread.currentThread().getName());
                }
                safeList.add(Thread.currentThread().getName());
            }).start();
        }
        try {
            //等待全部线程执行完
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("unSafeList size : "+unSafeList.size());
        System.out.println("safeList size : "+safeList.size());
    }
}

六.锁

6.1死锁

案例：用一双筷子吃饭

/**
 * 死锁：多个线程互相占有对方想要的资源
 */
public class DeadLock extends Thread{
    public static void main(String[] args) {
        DeadLock one = new DeadLock(1);
        DeadLock two = new DeadLock(2);
        one.start();
        two.start();
    }

    public static ChopstickOne chopstickOne = new ChopstickOne();
    public static ChopstickTwo chopstickTwo = new ChopstickTwo();
    public Integer choose;

    public DeadLock(Integer choose){
        this.choose = choose;
    }
    @Override
    public void run() {
        try {
            eat();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    /**
     *choose为1：先拿到第一只筷子,休眠1秒等待其他线程执行,然后拿到第二只筷子
     *choose为2：先拿到第二只筷子，休眠2秒等待其他线程执行,然后拿到第一只筷子
     */
    private void eat() throws InterruptedException {
        if (choose == 1){
            synchronized (chopstickOne){
                System.out.println(Thread.currentThread().getName()+"拿到了,chopstickOne锁");
                Thread.sleep(1000);
                /**
                 * 死锁解决：把这个同步块放在外面和上一个同步块处于平级位置
                 */
                synchronized (chopstickTwo){
                    System.out.println(Thread.currentThread().getName()+"拿到了,chopstickTwo");
                }
            }
        }else if (choose == 2){
            synchronized (chopstickTwo){
                System.out.println(Thread.currentThread().getName()+"拿到了,chopstickTwo");
                Thread.sleep(2000);
                synchronized (chopstickOne){
                    System.out.println(Thread.currentThread().getName()+"拿到了,chopstickOne锁");
                }
            }
        }
    }
}

/**
 * 筷子1：第一只筷子
 */
class ChopstickOne{}

/**
 * 筷子2：第二只筷子
 */
class ChopstickTwo{}

6.2可重入锁，显式的锁

public class TestLock implements Runnable{
    public Integer numbers = 10;
    public Boolean flag = true;
    ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        try {
            Thread.sleep(100);
            //加锁
            lock.lock();
            while(flag){
                if (numbers <= 0){
                    flag = false;
                }
                System.out.println(Thread.currentThread().getName()+"买了一张票,票还有："+numbers--);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            //释放锁
            lock.unlock();
        }

    }

    public static void main(String[] args) {
        TestLock testLock = new TestLock();
        new Thread(testLock,"t1").start();
        new Thread(testLock,"t2").start();
        new Thread(testLock,"t3").start();
    }
}

七.线程间的通信

7.1生产者和消费者问题

持爱
关注
专栏目录
Java多线程干货系列（1）Java多线程基础编程开发技术
11-22
Java多线程是Java编程中的重要...以上内容仅涵盖了Java多线程基础编程的一部分知识点，实际开发中还需要关注更多的并发控制策略、性能优化和调试技巧。对于深入理解Java多线程，还需要学习和实践更多相关的高级特性。
Java多线程-基础
weixin_44319442的博客
03-28 378
上下文切换 上下文切换指 cpu 从一个进程（或线程）切换到另一个进程（或线程）。上下文指某一时间点cpu 寄存器和程序计数器的内容。 上下文切换通常是计算密集型的，意味着此操作会消耗大量 cpu 时间，所以线程不是越多越好。 实现多线程方式 继承 Thread 类 实现 Runnable 接口 Thread类的几个常用方法： concurrentThread：返回当前正在执行的线程对象 start：开始执行线程，java虚拟机会调用 线程的 run 方法 yield：当前线程让出处理器的
Java多线程基础-01、数组概述.rar
11-20
本资料“Java多线程基础-01、数组概述”将带你入门Java的多线程世界，并结合数组这一基本数据结构进行讲解。 首先，我们需要理解什么是线程。线程是操作系统分配CPU时间的基本单位，一个进程可以有多个线程，它们...
Java 多线程基础笔记
最新发布
08-17
Java 多线程基础笔记
Java多线程基础-03、数组定义方式二、元素默认值规则.rar
11-20
总之，Java多线程基础是高效编程的关键，而理解数组定义和元素默认值规则则是构建安全、健壮的多线程程序的基础。通过合理运用多线程技术和掌握数组的内在特性，你可以编写出更加高性能、可扩展的Java应用程序。
一篇文章弄懂Java多线程基础和Java内存模型
12-21
Java多线程是并发编程的重要组成部分，理解和掌握其基础以及Java内存模型对于任何Java开发者来说都是必不可少的。本文将深入探讨这两个主题。 首先，我们来理解多线程的生命周期及其五种基本状态： 1. 新建状态...
java多线程基础
qq_45903614的博客
05-14 247
java多线程基础1.线程的相关概念2.线程的启动方式 1.线程的相关概念 进程： 进程就是一个程序或者服务运行的过程在操作系统中的体现，即操作系统中一个独立运行的程序或者服务就是一个进程。 多进程： 现在的操作系统都支持同时运行多个程序或者服务，体现在进程上，就是多个进程可以并行的执行，这称之为操作系统支持多进程。 线程： 一个进程的内部还可以划分出多个并行执行的过程，称之为在进程内部存在线程，线程是操作系统能够进行运算调度的最小单位。 多线程： 一个进程可以存在多个线程，并且这些线程可以并行的执行，这
尚硅谷_java多线程_学习笔记
qq_17079255的博客
10-08 1676
文章标题
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

持爱

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值