java-多线程

最新推荐文章于 2024-07-19 17:37:28 发布
最新推荐文章于 2024-07-19 17:37:28 发布
阅读量166 收藏 1
点赞数 1
文章标签： java 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/aagjkgluhgyy/article/details/113992492
版权

多线程

Process与Thread

注意：

很多多线程是模拟出来的，真正的多线程是指多个CPU即多核，如多个服务器，如果是模拟出来的就是在一个CPU的情况下在同一个 时间切换不同的工作，切换时间很短所以照成同时执行的错觉

  • 进程与程序相关联，程序师指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的概念
  • 进程是执行程序的一次执行过程，是一个动态的概念，是系统资源分配的单位
  • 一个进程可以包含若干个线程，一个进程必须有一个线程不然这个进程没有意义，线程就是CPU调度和执行的单位

继承Thread

  1. 写一个类继承Thread
  2. 重写run方法
  3. 调用start()方法启动线程
  4. 线程交替执行
  5. 线程不一定立即执行，由CPU调度执行
  6. 不建议使用，避免OOP单继承局限性
public class Test extends Thread {

    public static void main(String[] args) {
        Test test = new Test();
        test.start();
        for (int i = 0; i <= 10; i++) {
            System.out.printf("执行主线程" + i + "\n");
        }

    }

    @Override
    public void run() {
        for (int i = 0; i <= 10; i++) {
            System.out.printf("执行子线程" + i + "\n");
        }
    }
}
执行主线程0
执行子线程0
执行主线程1
执行子线程1
执行主线程2
执行子线程2

实现Runable接口

  1. 实现Runable接口
  2. 重写run方法
  3. New一个Thread丢入Runable的实现类，start()启动
  4. 推荐使用，避免单继承局限性，灵活方便，方便同一个对象被多个线城使用
public class Test implements Runnable {

    public static void main(String[] args) {
        Test test = new Test();
        new Thread(test).start();
    }
    @Override
    public void run() {
        for (int i = 0; i < 6; i++) {
            System.out.printf("测试" + i + "\n");
        }
    }
}
测试0
测试1
测试2
测试3
测试4
测试5

静态代理

  1. 找一个中间商实现附属功能，自己只需要做当前的事情即可
  2. 例子：A结婚，委托婚庆公司B,A只需要去结婚即可，B帮助其布置场地以及收尾等等
//封装一个接口,即要做的事情
public interface Marry {
    //去结婚
    void toMarry();
}
/*
    代理角色，中间商
    实现Marry接口，即实现要做的事情
    在重写方法中实现附属工作，即布置场地收尾等等
    然后调用Body()方法，Body()就是要去结婚的人
 */
public class Server implements Marry {

    public static void main(String[] args) {
        new Server(new Body()).toMarry();
    }

    private Body body;

    public Server(Body body) {
        this.body = body;
    }

    @Override
    public void toMarry() {
        System.out.printf("布置现场" + "\n");
        body.toMarry();
        System.out.printf("收钱回家" + "\n");
    }
}
//结婚的人,只需要去结婚就行
public class Body implements Marry {
    @Override
    public void toMarry() {
        System.out.printf("男孩正在结婚" + "\n");
    }
}
输出结果:
布置现场
男孩正在结婚
收钱回家

线程五种状态

1. new Thread()代表新生
2. 调用start()进入就绪状态，等待CPU调度，不一定立即执行
3. CPU调度线程两种情况
   	1. 阻塞状态
        	1. 当调用sleep/wait/同步锁定时，线程进入阻塞状态，阻塞状态结束后继续进入就绪状态等段CPU调度
       	2. 死亡状态
         	1. 线程中断/结束,一旦进入该状态线程就不能再次启动

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KOJv173E-1614066334796)(C:\Users\Administrator\Desktop\aa.png)]

线程停止

  1. 不推荐使用JDK提供的stop()/destory()方法
  2. 推荐线程自己销毁停止
  3. 建议使用一个线程销毁变量来停止线程操作
/*
        假停止
        返回值为True代码中执行停止线程操作,否则相反
     */
static boolean isStop = false;//默认不停止
public static boolean isStopThread(int a) {
    if (a > 10) {
        isStop = true;
    } else {
        isStop = false;
    }
    return isStop;
}

线程休眠

  • sleep存在异常InterrruptedExcetion
  • sleep时间达到后线程进入就绪状态
  • sleep可以模拟网络延时，倒计时等
  • 每一个对象都有一个锁，sleep不会释放锁
// sleep模拟倒计时
public static void main(String[] args) throws InterruptedException {
    toTest();
}

public static void toTest() throws InterruptedException {
    int number = 10;
    while (true) {
        Thread.sleep(1000);
        System.out.printf("" + number--);
        if (number <= 0) {
            break;
        }
    }
}

线程礼让

  • yield 让当前执行的线程停止，不阻塞
  • 将线程转为就绪状态
  • 礼让不一定成功，看CPU心情
public class TestYield {
    public static void main(String[] args) {
        YirldThread yirldThread = new YirldThread();
        new Thread(yirldThread, "a").start();
        new Thread(yirldThread, "b").start();
    }


    static class YirldThread implements Runnable {

        @Override
        public void run() {
            System.out.printf(Thread.currentThread().getName() + "线程开始" + "\n");
            Thread.yield();//礼让
            System.out.printf(Thread.currentThread().getName() + "线程停止" + "\n");
        }
    }
}

线程强制执行

  • Join合并线程,待此线程执行完成之后其他线程继续，其他线程阻塞
  • 通俗理解：插队
public class TestJoin implements Runnable {

    public static void main(String[] args) throws InterruptedException {
        TestJoin testJoin = new TestJoin();
        Thread thread = new Thread(testJoin);
        thread.start();
        for (int i = 0; i < 6; i++) {
            if (i == 3){//当Main线程运行到3的时候TestJoin线程插队，等待TestJoin运行完成Main线程继续
                thread.join();
            }
            System.out.printf("主线程" + i+"\n");
        }
    }

    @Override
    public void run() {
        for (int i = 0; i < 6; i++) {
            System.out.printf("子线程" + i+"\n");
        }
    }

}
主线程0
子线程0
主线程1
子线程1
主线程2
子线程2
子线程3
子线程4
子线程5
主线程3
主线程4
主线程5

线程优先级

  • 优先级用数字表示范围1-10
public class TestState {

    public static void main(String[] args) {
        A a = new A();
        Thread thread = new Thread(a);
        thread.setPriority(10);//设置优先级
        thread.start();
        System.out.printf("" + thread.getPriority());//获取优先级
    }


    static class A implements Runnable {

        @Override
        public void run() {

        }
    }
}

守护线程Daemon

  • 线程分为用户线程和守护线程
  • 虚拟机必须确保用户线程执行完毕
  • 虚拟机不用等待守护线程执行完毕
  • 比如：后台记录操作日志，监控内存，垃圾回收等守护线程
  • 用户线程执行完毕对应守护线程也随之结束
public class TestDaemon {

    public static void main(String[] args) {
        You you = new You();
        Server server = new Server();
        Thread thread = new Thread(server);
        thread.setDaemon(true);//设置守护线程
        thread.start();
        new Thread(you).start();//用户线程

    }

    //用户线程
    static class You implements Runnable {

        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                System.out.printf("凡人" + i + "\n");
            }
        }
    }

    //守护线程
    static class Server implements Runnable {

        @Override
        public void run() {
            while (true) {
                System.out.printf("上帝" + "\n");
            }
        }
    }
}

线程同步(安全性)

  • 由于一个进程的多个线程共享一块存储空间，所有存在冲突问题，为啦保证访问时的数据的正确性，在访问时加入锁synchronized,当一个线程获取这个对象的排它锁时，独占资源，其他线程必须等待，执行完成释放即可
  • 比如买票多个人抢一张票
  • 存在隐患
    • 一个线程持有锁会导致其他同样使用该锁的线程挂起
    • 在多线程竞争下，加锁释放锁会导致性能问题
    • 如果高优先级等待低优先级释放锁会导致性能倒置问题
  • synchronized锁的时当前this
  • 锁的对象一定是变化的量，增删改
//买票  同步锁(锁一个方法)
public class UnSecurity {

    public static void main(String[] args) {
        BuyPaio buyPaio = new BuyPaio();
        new Thread(buyPaio, "张三").start();
        new Thread(buyPaio, "李四").start();
        new Thread(buyPaio, "王五").start();
    }

    static class BuyPaio implements Runnable {

        private int num = 11;//余票

        boolean flag = true;//手动停止线程

        @Override
        public void run() {
            while (flag) {
                try {
                    toBuy();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }

        //synchronized同步方法  安全锁线程同步，不加锁可能买到负数票
        public synchronized void toBuy() throws InterruptedException {
            if (num <= 0) {
                flag = false;
                System.out.printf("暂无余票" + "\n");
                return;
            } else {
                Thread.sleep(100);
                num--;
                System.out.printf(Thread.currentThread().getName() + "买到第" + num + "张票" + "\n");
            }
        }
    }

}

//锁一个代码块
synchronized(Object){
    
}

死锁

  • 某一个同步代码块拥有两个以上对象的锁就可以死锁

Lock

  • 显示定义同步锁
public class TestLock {

    public static void main(String[] args) {
        BuyPaio buyPaio = new BuyPaio();
        new Thread(buyPaio, "张三").start();
        new Thread(buyPaio, "李四").start();
        new Thread(buyPaio, "王五").start();
    }

    static class BuyPaio implements Runnable {

        //定义Lock锁
        ReentrantLock lock = new ReentrantLock();
        private int num = 11;//余票

        boolean flag = true;//手动停止线程

        @Override
        public void run() {
            while (flag) {
                try {
                    lock.lock();//加锁
                    toBuy();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    lock.unlock();//解锁
                }
            }
        }

        //synchronized同步方法  安全锁线程同步，不加锁可能买到负数票
        public void toBuy() throws InterruptedException {
            if (num <= 0) {
                flag = false;
                System.out.printf("暂无余票" + "\n");
                return;
            } else {
                Thread.sleep(100);
                num--;
                System.out.printf(Thread.currentThread().getName() + "买到第" + num + "张票" + "\n");
            }
        }
    }
}

线程池

public class Main {

    public static void main(String[] args) {
        //创建线程池
        ExecutorService service = Executors.newFixedThreadPool(10);
        service.execute(new Test());
        service.execute(new Test());
        service.execute(new Test());
        service.execute(new Test());
        //关闭
        service.shutdown();
    }
}

class Test implements Runnable {

    @Override
    public void run() {
        System.out.printf("线程执行" + "\n");
    }
}
初见-Android
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
6-1 jmu-Java-07多线程-Thread (20分)
sddfnsff的博客
05-26 5990
编写MyThread类继承自Thread。创建MyThread类对象时可指定循环次数n。 功能：输出从0到n-1的整数。 并在最后使用System.out.println(Thread.currentThread().getName()+" "+isAlive())打印标识信息 裁判测试程序： import java.util.Scanner; /这里放置你的答案，即MyThread类的代码/ public class Main { public static void main(String[] args
Java-多线程-给线程命名
yy310585的博客
01-17 3826
Java-多线程-给线程命名 在Java中，通过继承Thread创建的线程，有以下两种方式可以给线程命名； 通过构造器命名 因为线程类继承自Thread类，所有也继承了Thread的name属性，可以通过super的方法调用父类构造器，将name传给构造器完成线程的命名 public class TestThread extends Thread{// 继承了Thread类之后...
12jmu-Java-07多线程-Thread
ihopeyousuccess的博客
11-30 2000
编写MyThread类继承自Thread。创建MyThread类对象时可指定循环次数n。 功能：输出从0到n-1的整数。 并在最后使用System.out.println(Thread.currentThread().getName()+" "+isAlive())打印标识信息 裁判测试程序： import java.util.Scanner; /这里放置你的答案，即MyThread类的代码/ public class Main { public static void main(String[] args
JAVA-多线程 所有文件
01-09
这个“JAVA-多线程 所有文件”压缩包很可能包含了一系列关于Java多线程学习的源代码示例和相关文档。下面我们将深入探讨Java多线程的相关知识点。 1. **线程的概念**：线程是操作系统分配CPU时间的基本单位，一个...
java-多线程 test
06-11
java-多线程 test
Java-多线程线程状态转换图
07-22
多线程线程状态转换图
Java-多线程连接池模型
07-22
多线程连接池模型
狂神说Java-多线程课程全部代码.rar
11-26
《狂神说Java-多线程课程全部代码》是一个涵盖了Java多线程和并发编程的实战教程资源。这个压缩包包含了一系列的示例代码（如demo01），旨在帮助开发者深入理解和掌握Java中的多线程技术及其在并发环境中的应用。 ...
Java内存模型
最新发布
weixin_44267758的博客
07-19 302
此处的变量不是指java编程中的变量，它包括了实例字段，静态字段和构成数值对象的元素，但不包括局部变量和方法参数。JMM规定所有变量都存储在主内存中。每条线程有自己的工作内存，工作内存中保留了该线程使用到变量的主内存的副本。线程对变量的所有操作都必须在工作内存中进行，不能直接读写主内存的变量，不同的线程间也无法直接访问对方工作内存的变量，线程之间的变量值传递需要通过主内存来完成。
JVM-垃圾回收与内存分配
m0_50846237的博客
07-19 557
JVM-垃圾回收与内存分配
day04：Redis和店铺营业状态设置
m0_69266818的博客
07-15 839
介绍了Redis命令和用java操作redis还有营业额状态接口的书写
【Java算法】前缀和 下
2302_79806056的博客
07-18 885
这段代码实现了一个寻找数组中具有相等数量的0和1的最长子数组长度的算法。具体来说，它使用了前缀和（prefix sum）的概念以及哈希映射（HashMap）来优化查找过程。初始化哈希映射：计算前缀和：检查相等数量的0和1：更新哈希映射：返回结果：这种方法的时间复杂度为O(n)，因为我们只遍历数组一次，并且对每个元素执行常数时间的操作。空间复杂度也是O(n)，最坏情况下需要存储n个前缀和值。 初始化阶段:开始遍历数组:继续
Java集合框架（JCF）——高效管理数据的利器
AdairRichard的博客
07-15 158
Java集合框架（Java Collections Framework，JCF）是Java提供的一套用于管理数据集合的类和接口的架构。它位于java.util包下，为开发者提供了一套丰富的接口和类来实现各种数据集合的创建、添加、删除、遍历等操作。Java集合框架是Java编程中非常重要的部分，它极大地简化了数据管理的复杂性，提高了开发效率。本文将介绍Java集合框架的基本概念、主要接口和类，以及它们之间的关系和使用场景。
【JAVA】相关程序组件
qq_44077764的博客
07-15 163
【JAVA】相关程序组件
Java 中有哪几种基本数据类型？请分别列出它们并简述每种数据类型的特点及其在内存中的占用空间？
liangzai215的专栏
07-15 501
在Java的世界里，数据是构建应用程序的基石。为了高效地处理这些数据，Java设计了一系列基础数据类型，它们直接映射到计算机硬件上，因此在性能和内存使用上更为高效。我们常说的Java八大基本数据类型，涵盖了整数、浮点数、字符和布尔值，下面我将一一介绍它们的特点以及在内存中的占用空间，并通过简单的代码实例来加深理解。
maven项目容器化运行之1-基于1Panel软件将docker镜像构建能力分享给局域网
qq_37372909的博客
07-15 522
docker核心功能包括镜像的构建和容器的运行，它可以开放端口将镜像构建的能力暴露。docker daeson就是docker的守护进程，开放能力是通过指定docker守护进程监听端口来实现的。后面开发人员就可以通过maven中docker插件来远程调用docker镜像构建能力了。
构建自动化的精粹：Gradle任务依赖性与执行顺序控制
liuxin33445566的博客
07-15 547
本文以"构建自动化的精粹：Gradle任务依赖性与执行顺序控制"为题，详细介绍了任务依赖性的重要性、基本配置、多个任务的依赖性、条件依赖性、错误处理、高级用法、多项目构建中的任务依赖性。随着Gradle的不断发展，我们可以预见到更多关于任务依赖性和构建自动化的高级特性的出现，这将进一步扩展Gradle的构建能力，满足更复杂的项目构建需求。任务依赖性定义了任务之间的执行关系，确保了在构建过程中，任务能够按照预期的顺序执行。任务是一个特殊的任务，它默认依赖于所有没有显式排除的任务。方法来指定任务的依赖性。
Java多线程编程详解
"Java多线程编程学习资料" 在Java编程中，多线程是一个重要的概念，它使得程序能够同时执行多个任务，提高了程序的效率和响应性。本章主要涵盖了五个关键部分： 1. **线程的概念与原理**： - 程序是一组静态指令...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值