Java 多线程（抢CPU）

已于 2024-07-04 18:52:44 修改
阅读量465 收藏 9
点赞数 4
文章标签： java 笔记
于 2024-03-19 22:29:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yesyesyes_yes/article/details/136820722
版权

哈哈哈

什么是多线程：可以让程序同时做多件事情。

多线程的作用：提高效率。

多线程的应用场景：想让多个事情同时运行。

 并发（多个指令在单个CPU交替执行）和并行（多个指令在多个CPU交替执行）

多线程的实现方式：

1.继承Thread类的方式实现（简单，扩展性差）

public class ss {
    public static void main(String[] args) {
        //1.自己定义一个类继承Thread
        //2.重写run方法
        //3.创建子类的对象，并启动线程
        MyThread t1=new MyThread();
        MyThread t2=new MyThread();

        t1.setName("1");
        t2.setName("2");

        t1.start();
        t2.start();
    }
}

public class MyThread extends Thread{
    @Override
    public void run(){
        for (int i = 0; i < 100; i++) {
            System.out.println(getName()+"hello");
        }
    }
}

2.实现Runnable接口的方式进行实现（复杂，扩展性强）

public class ss {
    public static void main(String[] args) {
        //1.自己定义一个类实现Runnable接口
        //2.重写里面的run方法
        //3.创建自己的类的对象
        //4.创建一个Thread类的对象，并开启线程
        MyRun mr=new MyRun();

        Thread t=new Thread(mr);
        Thread t2=new Thread(mr);

        t.setName("1");
        t2.setName("2");

        t.start();
        t2.start();
    }
}
public class MyRun implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            Thread t=Thread.currentThread();
            System.out.println(t.getName()+"hello");
        }
    }
}

3.利用Callable接口和Future接口方式实现（可以获取结果）

import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.FutureTask;

public class ss {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //1.创建一个类MyCallable实现Callable接口
        //2.重写call
        //3.创建MyCallable对象
        //4.创建FutureTask的对象
        //5.创建Thread类对象并启动
        MyCallable mc=new MyCallable();

        FutureTask<Integer> ft=new FutureTask<>(mc);

        Thread t1=new Thread(ft);

        t1.start();

        Integer result=ft.get();
        System.out.println(result);

    }
}
import java.util.concurrent.Callable;

public class MyCallable implements Callable<Integer>{
    @Override
    public Integer call() throws Exception{
        int sum=0;
        for (int i = 0; i < 100; i++) {
            sum=sum+i;
        }
        return sum;
    }

}

多线程的常用成员方法

public class ss {
    public static void main(String[] args) throws InterruptedException {
        //getName
        MyThread mt=new MyThread("111");
        MyThread t2=new MyThread();

        mt.start();
        t2.start();
        //setName
        //....

        //currentThread
        Thread t=Thread.currentThread();
        System.out.println(t.getName());

        //sleep(long time)毫秒 睡眠时间
        System.out.println("11111");
        Thread.sleep(5000);
        System.out.println("22222");

    }
}

public class MyThread extends Thread{
    public MyThread() {
    }

    public MyThread(String name) {
        super(name);
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println(getName()+"@"+i);
        }
    }
}

线程的优先级

public class ss {
    public static void main(String[] args) throws InterruptedException {
        MyRunnable mr=new MyRunnable();

        Thread t1=new Thread(mr,"1");
        Thread t2=new Thread(mr,"2");

        System.out.println(t1.getPriority());//默认优先级5
        System.out.println(t2.getPriority());//默认优先级5//最小1//最大10

        t1.setPriority(1);
        t2.setPriority(10);

        t1.start();
        t2.start();

    }
}

public class MyRunnable implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName()+"@"+i);

        }
    }
}

守护线程（起码有2个线程）

public class ss {
    public static void main(String[] args) throws InterruptedException {
        MyThread t1=new MyThread();
        MyThread2 t2=new MyThread2();

        t1.setName("1");
        t2.setName("2");

        t2.setDaemon(true);

        t1.start();
        t2.start();

    }
}
public class MyThread extends Thread{

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(getName()+"@"+i);
        }
    }
}

public class MyThread2 extends Thread{

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(getName()+"@"+i);
        }
    }
}

礼让线程

public class ss {
    public static void main(String[] args) throws InterruptedException {
        MyThread2 t1=new MyThread2();
        MyThread2 t2=new MyThread2();

        t1.setName("1");
        t2.setName("2");

        t1.start();
        t2.start();

    }
}

public class MyThread2 extends Thread{

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(getName()+"@"+i);
            Thread.yield();//礼让一下，再重新抢夺CPU的执行权
        }
    }
}

插入线程/插队线程

public class ss {
    public static void main(String[] args) throws InterruptedException {
        MyThread t1=new MyThread();
        t1.setName("1");
        t1.start();
        
        t1.join();//把t线程插入到当前线程（main）之前

        for (int i = 0; i < 10; i++) {
            System.out.println("main"+i);
        }

    }
}

public class MyThread extends Thread{

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

线程的生命周期：

一个线程从创建，到结束。

线程的安全问题

（下面这个代码存在问题）

public class ss {
    public static void main(String[] args) throws InterruptedException {
        MyThread t1=new MyThread();
        MyThread t2=new MyThread();
        MyThread t3=new MyThread();

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}

public class MyThread extends Thread{

    static int ticket=0;//这个类所有对象共享ticket数据（加了static）
    @Override
    public void run() {
        while (true){
            if(ticket<100){
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                ticket++;
                System.out.println(getName()+"正在卖第"+ticket+"张票");
            }else break;
        }
    }
}

同步代码块

（可以解决问题）

public class ss {
    public static void main(String[] args) throws InterruptedException {
        MyThread t1=new MyThread();
        MyThread t2=new MyThread();
        MyThread t3=new MyThread();

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}

public class MyThread extends Thread{

    static int ticket=0;//这个类所有对象共享ticket数据（加了static）

    static Object obj=new Object();
    @Override
    public void run() {
        while (true){
            synchronized (obj){
                if(ticket<100){
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    ticket++;
                    System.out.println(getName()+"正在卖第"+ticket+"张票");
                }else break;
            }
        }
    }
}

同步方法：

就是把synchronized关键字加到方法上

public class ss {
    public static void main(String[] args) throws InterruptedException {
        MyRunnable mr=new MyRunnable();

        Thread t1=new Thread(mr);
        Thread t2=new Thread(mr);
        Thread t3=new Thread(mr);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}

public class MyRunnable implements Runnable{
    int ticket=0;
    @Override
    public void run() {
        while (true){
                if (method()) break;
        }
    }

    private synchronized boolean method() {
        if(ticket==100){
            return true;
        }else{
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            ticket++;
            System.out.println(Thread.currentThread().getName()+"在卖第"+ticket+"张票");
        }
        return false;
    }
}

lock锁

死锁

等待唤醒机制

1.消费者

2.生产者

public class Test {
    public static void main(String[] args) {
        Cook c=new Cook();
        Foodie f=new Foodie();

//        c.setName("厨师");
//        f.setName("吃货");

        c.start();
        f.start();
    }
}

public class Foodie extends Thread{
    @Override
    public void run() {
        while (true){
            synchronized (Desk.lock){
                if(Desk.count==0){
                    break;
                }else{
                    if(Desk.foodFlag==0){
                        try {
                            Desk.lock.wait();
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                    }
                    else{
                        Desk.count--;
                        System.out.println("吃货还能吃"+Desk.count+"碗");
                        Desk.lock.notifyAll();
                        Desk.foodFlag=0;
                    }
                }
            }
        }
    }
}

public class Cook extends Thread{
    @Override
    public void run() {
        while (true){
            synchronized (Desk.lock){
                if(Desk.count==0){
                    break;
                }else {
                    if (Desk.foodFlag==1){
                        try {
                            Desk.lock.wait();
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                    }else {
                        System.out.println("厨师做了一碗面条");
                        Desk.foodFlag=1;
                        Desk.lock.notifyAll();
                    }
                }
            }
        }
    }
}

public class Desk {
    public static int foodFlag=0;//桌上是否有食物

    public static int count=10;

    public static Object lock=new Object();

}

利用阻塞队列方式实现

import java.util.concurrent.ArrayBlockingQueue;

public class Test {
    public static void main(String[] args) {
        ArrayBlockingQueue<String> queue=new ArrayBlockingQueue<>(1);

        Cook c=new Cook(queue);
        Foodie f=new Foodie(queue);

        c.start();
        f.start();

    }
}

import java.util.concurrent.ArrayBlockingQueue;

public class Foodie extends Thread{
    ArrayBlockingQueue<String> queue;

    public Foodie(ArrayBlockingQueue<String>queue){
        this.queue=queue;
    }
    @Override
    public void run() {
        while (true){
            try {
                String food=queue.take();
                System.out.println(food);

            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

public class Desk {
    public static int foodFlag=0;//桌上是否有食物

    public static int count=10;

    public static Object lock=new Object();

}

import java.util.concurrent.ArrayBlockingQueue;

public class Cook extends Thread{
    ArrayBlockingQueue<String> queue;

    public Cook(ArrayBlockingQueue<String>queue){
        this.queue=queue;
    }

    @Override
    public void run() {
        while (true){
            try {
                queue.put("面条");
                System.out.println("厨师做了一碗面条");
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

多线程的6种状态

 线程池：

1.创建线程池

2.提交任务

3.所有任务全部执行完毕，关闭线程池

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class n {
    public static void main(String[] args) {
//    1.获取线程池对象
//        ExecutorService pool1=Executors.newCachedThreadPool();//无上限
        ExecutorService pool1=Executors.newFixedThreadPool(3);//有上限

//    2.提交任务
        pool1.submit(new MyRunnable());
        pool1.submit(new MyRunnable());
        pool1.submit(new MyRunnable());
        pool1.submit(new MyRunnable());

//    3.销毁线程池
        pool1.shutdown();
    }
}

public class MyRunnable implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName()+"---"+i);
        }
    }
}

自定义线程池

回头再看

最大并行数

4核8线程：最大并行数8

public class sa {
    public static void main(String[] args) {
        int count=Runtime.getRuntime().availableProcessors();
        System.out.println(count);
    }
}

线程池多大合适

CPU密集型运算 最大并行数+1

I/O密集型运算 最大并行数*期望CPU利用率*（总时间(CPU计算时间+等待时间)/CPU计算时间）

多线程的额外扩展内容

回头再看

栀栀栀
关注
java多线程抢占资源_Java多线程整理
weixin_28880179的博客
02-16 1817
一、线程池过于频繁的创建/销毁线程浪费性能，线程并发数量过多，JVM调度是抢占式的，线程上线文切换抢占系统资源导致阻塞。1.线程池线程数：一般CPU密集型：CPU+1IO密集型：[(线程等待时间+线程CPU时间)/线程CPU时间]*CPU2.线程池创建4种方式：newCachedThreadPool 缓存线程池，没有线程可用就创建，空闲线程60秒未使用将被回收。newFixedThreadPoo...
线程抢占CPU问题
qq_42710573的博客
08-05 1979
public class Work0805 { public static void main(String[] args) { Door d = new Door(); Thread t1 = new Thread(d, "中门"); Thread t2 = new Thread(d, "前门"); Thread t3 = new Thread(d, "后门"); t1...
Java多线程抢占
a846029405的博客
03-22 633
[url]https://blog.dreamtobe.cn/2015/03/25/Java%E5%A4%9A%E7%BA%BF%E7%A8%8B%E6%8A%A2%E5%8D%A0/[/url]
java 多线程与cpu_java 多线程是什么?一个cpu怎么同时处理多个程序
weixin_36275605的博客
02-12 466
进程是程序在处理机中的一次运行。一个进程既包括其所要执行的指令，也包括了执行指令所需的系统资源，不同进程所占用的系统资源相对独立。所以进程是重量级的任务，它们之间的通信和转换都需要操作系统付出较大的开销。线程是进程中的一个实体，是被系统独立调度和分派的基本单位。线程自己基本上不拥有系统资源，但它可以与同属一个进程的其他线程共享进程所拥有的全部资源。所以线程是轻量级的任务，它们之间的通信和转换只需要...
java多线程
abeamoflight的博客
06-28 836
线程池其实就是一种多线程处理形式，处理过程中可以将任务添加到队列中，然后在创建线程后自动启动这些任务。1、网购商品秒杀2、云盘文件上传和下载3、12306网上购票系统等只要有并发的的地方、任务数量大或小、每个任务执行时间长或短的都可以使用线程池;只不过在使用线程池的时候,注意一下设置合理的线程池大小即可;
java多线程总结（转载）
weixin_34255055的博客
06-22 174
Java多线程编程总结 2007-05-17 11:21:59 　标签：java 多线程　　　 [推送到技术圈] 版权声明：原创作品，允许转载，转载时请务 必以超链接形式标明文章 原始出处 、作者信息和本声明。否则将追究法律责任。http://lav...
Java多线程知识点总结
08-19
Java多线程是Java编程语言中一个非常重要的概念，它允许开发者在一个程序中创建多个执行线程并行运行，以提高程序的执行效率和响应速度。在Java中，线程的生命周期包含五个基本状态，分别是新建状态（New）、就绪...
java多线程导出excel（千万级别）优化
12-05
Java多线程导出Excel是处理大数据量时的一种高效策略，尤其在面对千万级别的数据时。传统的Apache POI库在处理大规模数据时可能会遇到栈溢出（StackOverflowError）和内存溢出（OutOfMemoryError）等问题，因为这些...
java 多线程
11-07
### Java多线程知识点详解 #### 一、Java Thread 概念 在Java中，**线程**是一种轻量级的进程，它是程序执行流的最小单元。一个标准的Java应用通常至少包含一个线程，即主（Main）线程。Java支持多线程编程，这...
Java多线程实例
09-03
Java多线程是Java编程中的重要概念，它允许程序同时执行多个任务，从而提高程序的效率和响应速度。在Java中，实现多线程有两种主要方式：继承`java.lang.Thread`类或实现`java.lang.Runnable`接口。 1. 继承Thread...
java_Thread.rar_java 多线程_java多线程
09-21
Java多线程是Java编程中的重要概念，它允许程序同时执行多个任务，从而提高系统资源的利用率和程序的响应速度。在Java中，通过实现Runnable接口或者继承Thread类可以创建并运行多线程。本资料"java_Thread.rar"提供...
java多线程---cpu历史及一些关键概念
weixin_30319097的博客
05-09 87
1.cpu与摩尔定律: 摩尔定律是由英特尔（Intel）创始人之一戈登·摩尔（Gordon Moore）提出来的。其内容为：当价格不变时，集成电路上可容纳的元器件的数目，约每隔18-24个月便会增加一倍，性能也将提升一倍。换言之，每一美元所能买到的电脑性能，将每隔18-24个月翻一倍以上。这一定律揭示了信息技术进步的速度。这一定律自2004年以来，似乎已经失效，失效的原因是由于硅晶...
Java 多线程抢占 编程_Java多线程编程
weixin_39714383的博客
02-13 271
编写具有多线程能力的程序经常会用到的方法有：run(),start(),wait(),notify(),notifyAll(),sleep(),yield(),join()还有一个重要的关键字：synchronized本文将对以上内容进行讲解。一：run()和start()示例1：public class ThreadTest extends Thread{public void run(){fo...
Java------多线程基础Thread与Runnable模拟并发抢夺资源
cz_chen_zhuo的博客
11-19 888
线程与进程 操作系统中会存在多个进程：这些进程包括系统进程、以及用户进程。 系统进程指：操作系统内部建立的进程。 用户进程指：用户程序建立的进程。 进程和线程的区别： 1.进程和进程之间不共享内存，进程是在独立的内存空间中运行的。 2.而线程则可以共享系统分配给这个进程的内存空间。 3.线程不仅能共享进程的内存，也拥有自己的内存空间，这段空间叫做线程栈，是在建立线程时由系统分配的，主要用来保存线程内部所使用的数据。 ...
线程抢占cpu资源的一幕
魔鬼的归宿
04-22 7523
去年学习操作系统的时候，提到进程之间会抢占cpu时间片，实现线程的并发。其实想象起来可能有些理想，感觉进程们都会乖乖的去按照时间片轮转来轮着执行，可是事实是，他们之间的竞争是异常的激烈。我们用三个线程买票的故事说明一下，其实进程之间也差不多。     我们用一段代码来演示一下，这段代码引用慕课网视频《细说多线程之Thread VS Runnable》，感兴趣的可以去看一下。 class M
Java多线程-多线程相关概念
最新发布
01-19
Java多线程技术是编程中不可或缺的一部分，它允许程序在同一时间执行多个任务，从而提高效率和响应速度。本文将深入探讨多线程相关的概念。 首先，我们要了解程序、进程和线程的区别。程序是一组指令的集合，静态...
JAVA多线程技术分享-39页PPT(winding)
05-10
Java多线程技术是软件开发中的重要组成部分，尤其在高并发场景下不可或缺。本文将深入探讨多线程技术的关键知识点，以及在实际开发中容易遇到的问题。 首先，基础概念是理解多线程的关键。`Thread.sleep(0)`看似无...
java多线程-cpu内存占用-定位分析
north hunter
03-08 1515
一，创建测试环境（windows） 二，定位 正文： 测试环境如下： 建立2个线程类，一个run死循环执行大量io，另一个run死循环执行1秒睡眠。main方法开启4线程，上述每个开启2个。 高占用如下： 下载process explorer可查看进程的详细信息： 可看出，java进程里2个线程高占用cpu。 现在大概定位问题了，如果对程序很熟悉
Java多线程、深入CPU级别原理分析
码农六子
09-08 1331
1、现代计算机理论模型与工作方式 现代计算机理论模型是基于冯-诺依曼计算机模型为基础的。 计算机在运行时，先从内存中取出第一条指令，通过控制器的译码，按照指令的要求，从存储器中取出数据进行指定的运算和逻辑操作等，然后再按照地址将结果送到内存中存储。接下来再取出第二条指令，在控制器的指挥下完成响应操作。以此重复，直至所有的指令都执行完毕。 程序和指令一样存储，按照程序编排顺序，一步步的取出指令，自动地完成指令规定的操作是计算机最基本的工作模型。这一原理最初是由美籍匈牙利数学家冯....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值