多线程-未完结

已于 2023-12-20 11:01:25 修改
阅读量82 收藏
点赞数 1
分类专栏： java学习 文章标签： java
于 2021-01-14 15:17:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/syt19980807/article/details/112611406
版权

1、多线程

1.1、进程、线程、多线程

程序：程序是指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的概率。

进程（Process）：进程是执行程序的一次执行过程，是一个动态的概念，是系统资源分配的单位。

线程（Thread）：线程是进程中执行运算的最小单位，是进程中的一个实体，是被系统独立调度和分派的基本单位，线程自己不拥有系统资源，只拥有一点在运行中必不可少的资源，但它可与同属一个进程的其它线程共享进程所拥有的全部资源。一个线程可以创建和撤消另一个线程，同一进程中的多个线程之间可以并发执行。

1.2、线程的创建

三种创建线程的方式：

1.继承Thread类
package dxc;

//创建线程方式一：继承Thread类，重写run()方法，调用start开启线程

//总结：注意线程开启不一定立即执行，由CPU调度执行
public class TestThread1 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println("线程创建方式一"+i);
        }
    }

    public static void main(String[] args) {
        //main线程，主线程

        //创建一个线程对象
        TestThread1 testThread1 = new TestThread1();
        //调用start方法
        testThread1.start();

        for (int i = 0; i < 2000; i++) {
            System.out.println("我在学习多线程"+i);
        }
    }
}
2.实现Runnable接口
package dxc;
//创建线程方式2：实现Runnable接口，重写run()方法，执行线程需要丢入runnable接口实现类，调动start方法
public class TestThread3 implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println("线程创建方式一"+i);
        }
    }
    
    public static void main(String[] args) {
        //main线程，主线程

        //创建一个线程对象
        TestThread3 testThread3 = new TestThread3();
//        //调用start方法
//        testThread3.start();

        new Thread(testThread3).start();
        for (int i = 0; i < 2000; i++) {
            System.out.println("我在学习多线程"+i);
        }
    }
}

小结：

  • 继承Thread类
    • 子类继承Thread类具备多线程能力
    • 启动线程：子类对象.start()
    • 不建议使用：避免OOP单继承局限性
  • 实现Runnable接口
    • 实现接口Runnable具有多线程能力
    • 启动线程：传入目标对象+Thread对象.start()
    • 推荐使用：避免单继承局限性，灵活方便，方便统一个对象被多个线程使用。

实验：用线程同时下载多个资源：

首先导入commons IO包，然后如下：

package dxc;
//练习Thread，实现多线程同步下载图片

import org.apache.commons.io.FileUtils;

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

public class TestThread2 extends Thread{

    private String url;//网络图片地址
    private String name;//保存的名字

    public TestThread2(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) {
        TestThread2 t1 = new TestThread2("http://img0.bdstatic.com/img/image/wise/1%E6%B8%85%E7%BA%AF%E7%BE%8E%E5%A5%B3.jpg","1.jpg");
        TestThread2 t2 = new TestThread2("http://wap.baidu.com/static/img/r/image/2014-04-18/a250be0f0af4d9dd116b4bf1f37dc5c6.jpg","2.jpg");
        TestThread2 t3 = new TestThread2("http://img0.bdstatic.com/img/image/wise/3%E8%B6%B3%E7%90%83%E5%AE%9D%E8%B4%9D.jpg","3.jpg");

        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();
        }
    }
}

多线程操作同一个资源：

package dxc;
//多个线程同时操作一个资源
//买车票

public class TestThread4 implements Runnable{

    //票数
    private int ticketNums=10;

    @Override
    public void run() {
        while (true){
            if (ticketNums<=0)
            {
                break;
            }
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"-->拿到了第"+ticketNums--+"票");
        }
    }

    public static void main(String[] args) {
        TestThread4 ticket = new TestThread4();
        new Thread(ticket,"小明").start();
        new Thread(ticket,"黄牛").start();
        new Thread(ticket,"小红").start();
    }
}


运行结果：
小红-->拿到了第8票
小红-->拿到了第7票
黄牛-->拿到了第10票
小明-->拿到了第9票
小红-->拿到了第10票
小明-->拿到了第3票
小红-->拿到了第4票
黄牛-->拿到了第5票
小红-->拿到了第6票
小红-->拿到了第2票
小红-->拿到了第1票
小红-->拿到了第0票
小红-->拿到了第-1票
黄牛-->拿到了第1票
小明-->拿到了第1票
    
    
    //发现问题：多个线程操作同一个资源的情况下，线程不完全，数据紊乱
3.实现Callable接口
package demo02;

import dxc.TestThread2;
import org.apache.commons.io.FileUtils;

import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.util.concurrent.*;

//线程创建方式3：实现Callable接口
//好处 1、可以定义返回值  2、可以抛出异常
public class TestCallable implements Callable<Boolean> {
    private String url;//网络图片地址
    private String name;//保存的名字

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

    //下载图片线程的执行体
    @Override
    public Boolean call() {
        WebDownloader webDownloader = new WebDownloader();
        webDownloader.downloader(url,name);
        System.out.println("下载了文件名为："+name);
        return true;
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        TestCallable t1 = new TestCallable("http://img0.bdstatic.com/img/image/wise/1%E6%B8%85%E7%BA%AF%E7%BE%8E%E5%A5%B3.jpg","1.jpg");
        TestCallable t2 = new TestCallable("http://wap.baidu.com/static/img/r/image/2014-04-18/a250be0f0af4d9dd116b4bf1f37dc5c6.jpg","2.jpg");
        TestCallable t3 = new TestCallable("http://img0.bdstatic.com/img/image/wise/3%E8%B6%B3%E7%90%83%E5%AE%9D%E8%B4%9D.jpg","3.jpg");

        //创建执行服务
        ExecutorService ser = Executors.newFixedThreadPool(3);

        //提交执行
        Future<Boolean> r1 =ser.submit(t1);
        Future<Boolean> r2 =ser.submit(t2);
        Future<Boolean> r3 =ser.submit(t3);

        //获取结果
        boolean rs1 = r1.get();
        boolean rs2 = r2.get();
        boolean rs3 = r3.get();
        System.out.println(rs1);
        System.out.println(rs2);
        System.out.println(rs3);


        //关闭服务
        ser.shutdownNow();

    }

}

class WebDownloader{
    public void downloader(String url,String name) {
        try {
            FileUtils.copyURLToFile(new URL(url),new File(name));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

静态代理

package proxy;
//静态代理模式总结：
/*
* 真实对象和代理对象都要实现同一个接口
* 代理对象要代理真实角色
*
* 好处：
* 代理对象可以做很多真实对象做不了的事情
* 真实对象可以专注做自己的事情
*
* */
public class StacticProxy {
    public static void main(String[] args) {
        You you = new You();


        new Thread(()-> System.out.println("我爱你")).start();

        new WeddingCompany(new You()).HappyMarry();
        

        WeddingCompany weddingCompany = new WeddingCompany(you);
        weddingCompany.HappyMarry();
    }
}

interface Marry{
    void HappyMarry();
}
//真是角色，你去结婚
class You implements Marry{

    @Override
    public void HappyMarry() {
        System.out.println("我结婚了，还行吧");
    }
}
//代理对象，帮组你去结婚
class WeddingCompany implements Marry{

    //代理对象--》真实角色
    private Marry target;

    public WeddingCompany(Marry target) {
        this.target = target;
    }

    @Override
    public void HappyMarry() {
        before();
        this.target.HappyMarry();//真实对象
        after();
    }

    private void after() {
        System.out.println("结婚之后收尾款");
    }

    private void before() {
        System.out.println("结婚之前布置现场");
    }
}

1.2线程状态

在这里插入图片描述

方法说明
setPriority(int newPriority)更改线程的优先级
static void sleep(long millis)在指定的毫秒数内让当前正在执行的线程休眠
void join()等待该线程终止
static void yield()暂停当前正在执行的线程对象，并执行其他线程
void interrupt()中断线程，别用这个线程
boolean isAlive()测试线程是否处于活动状态
Thread.currentThead（）获取当前线程对象
getPriority（）获取当前线程的优先级

线程分为用户线程和守护线程

package state;


//测试守护线程
//上帝守护你
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);//默认是false表示是用户线程，正常都是用户线程


        thread.start();//上帝守护线程启动

        new Thread(you).start(); //你用户线程启动
    }
}

//上帝
class God implements Runnable{

    @Override
    public void run() {
        while (true){
            System.out.println("上帝保佑你");
        }
    }
}

//你
class You implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 36500; i++) {
            System.out.println("你一生都开心的活着");
        }
        System.out.println("======GoodBye! world==========");
    }
}

1.3线程同步

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

三个经典例子：

package syn;

public class UnsafeBank {
    public static void main(String[] args) {
        Account account = new Account(1000,"买房");
        Drawing you = new Drawing(account,50,"你");
        Drawing girl = new Drawing(account,100,"girl");
        you.start();
        girl.start();
    }
}

//账户
class Account {
    int money;//余额
    String name;

    public Account(int money, String name) {
        this.money = money;
        this.name = name;
    }
}

//银行:模拟取款
class Drawing extends Thread{
    Account account;//账户

    //取了多少钱
    int drawingMoney;
    //手里的钱
    int nowMoney;

    public Drawing(Account account,int drawingMoney,String name)
    {
        super(name);
        this.account = account;
        this.drawingMoney = drawingMoney;
    }

    //取钱
    @Override
    public void run() {
        //锁的对象就是变化的量，需要增删改的对象
        synchronized (account){
            //判断有没有钱
            if (account.money - drawingMoney < 0 )
            {
                System.out.println(Thread.currentThread().getName()+"钱不够，取不了");
                return;
            }

            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //余额
            account.money  = account.money - drawingMoney;
            //手里的钱
            nowMoney = nowMoney +drawingMoney;

            System.out.println(account.name + "余额为"+account.money);
            System.out.println(this.getName()+"手里的钱"+nowMoney);
        }

    }
}



package syn;
//不安全的买票

public class UnsafeBuyTicket {

    public static void main(String[] args) {
        BuyTicket buyTicket = new BuyTicket();
        new Thread(buyTicket,"苦逼的我").start();
        new Thread(buyTicket,"牛逼的你们").start();
        new Thread(buyTicket,"可恶的黄牛党").start();
    }
}

class BuyTicket implements Runnable{

    //票
    private  int ticketNums = 10;
    private boolean flag = true;

    @Override
    public void run() {
        //买票
        while (flag)
        {
            try {
                buy();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    private synchronized void buy() throws InterruptedException {
        //判断是否有票
        if(ticketNums<=0){
            flag = false;
            return;
        }
        //模拟延时
        Thread.sleep(200);
        //买票
        System.out.println(Thread.currentThread().getName()+"拿到了"+ticketNums--);
    }
}



package syn;

import java.util.ArrayList;
import java.util.List;

public class UsafeList {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        for (int i = 0; i < 10000; i++) {
            new Thread(()->{
                synchronized (list)
                {
                    list.add(Thread.currentThread().getName());
                }

            }).start();
        }
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(list.size());
    }
}

使用线程池

  BlockingQueue<Runnable> queue = new LinkedBlockingDeque<>(20000);
  ExecutorService executorService;= new ThreadPoolExecutor(2, 500, 60, TimeUnit.MINUTES, queue);
Executors.newFixedThreadPool创建⼀个固定⼤⼩的线程池，可控制并发的线程数，超出的线程会在队列中等待
Executors.newCachedThreadPool创建⼀个可缓存的线程池，若线程数超过处理所需，缓存⼀段时间后会回收，若线程数不够，则新建线程
Executors.newSingleThreadExecutor创建单个线程数的线程池，它可以保证先进先出的执⾏顺
Executors.newScheduledThreadPool创建⼀个可以执⾏延迟任务的线程池
Executors.newSingleThreadScheduledExecutor创建⼀个单线程的可以执⾏延迟任务的线程池
Executors.newWorkStealingPool创建⼀个抢占式执⾏的线程池（任务执⾏顺序不确定）【JDK1.8 添加】
ThreadPoolExecutor最原始的创建线程池的⽅式，它包含了 7 个参数可供设置，后⾯会详细讲
在工作上迷茫的码农
关注
专栏目录
并发编程之线程池的使用及扩展和优化
ignore
01-04 1954
前言多线程的软件设计方法确实可以最大限度的发挥现代多核处理器的计算能力，提高生产系统的吞吐量和性能。但是，如果一个系统同时创建大量线程，线程间频繁的切换上下文导致的系统开销将会拖慢整个系统。严重的甚至导致内存耗尽导致OOM异常。因此，在实际的生产环境中，线程的数量必须得到控制，盲目的创建大量新车对系统是有伤害的。那么，怎么才能最大限度的利用CPU的性能，又能保持系统的稳定性呢？其中有一个方法就是使用
多线程-共享全局变量问题
Devin12345的博客
08-08 3238
文章目录多线程-共享全局变量问题多线程可能遇到的问题同步计算错误的结果互斥锁死锁 多线程-共享全局变量问题 多线程可能遇到的问题 假设有两个线程t1和t2，都要对一个变量g_num进行运算(+1)，两个进程t1和t2分别对g_num各加10次，g_num的最终结果？ import threading import time g_num=0 def work1(num): global g...
java多线程实现大批量数据导入源码
09-29
java多线程实现大批量数据切分成指定份数的数据，然后多线程处理入库或者导出，线程的个数和每份数据的数量都可以控制
多线程编程学习笔记
weixin_42098332的博客
09-16 816
目录概述1、多线程实现方式2、继承Thread1、使用2、网图下载3、实现Runable接口4、并发问题6、龟兔赛跑7、实现Callable接口8、静态代理9、Lambda1、推导lamadba表达式2、带参简化10、线程状态1、线程停止2、线程休眠Sleep模拟网络延时3、线程礼让4、线程强制执行5、线程状态观测6、线程优先级7、守护线程11、线程同步1、三大不安全案例2、同步方法和同步块3、JUC12、死锁13、Lock14、线程协作1、生产者消费者管程法信号灯法2、线程池 概述 笔记参照b站up主：遇
JAVA线程池优化
liuhao0610的博客
09-09 457
前言： 随着信息技术的进步，各行各业对数据价值的重视程度急剧上升，越来越多的数据被分门别类地积聚下来，对数据库的并发要求越来越高，即同一时间点的数据请求越来越多，对实时性的要求也越来越高。实时性其实是不经过批量排队的高并发实时请求的代名词，同一时间的请求量和请求的处理速度直接决定了并发度： 1.优化的代码 //参数初始化 private static final int CPU_COUNT = R...
Java之线程池优化
jay_888的博客
05-21 229
参考资料及博客： https://www.cnblogs.com/10158wsj/p/8338367.html https://www.cnblogs.com/XHJT/p/3905665.html https://zhidao.baidu.com/question/1116525725491169459.html
vc++ multithread多线程教程---线程通信--利用事件对象,线程同步--使用信号量,线程同步--使用互斥量,线程同步--使用临界区
04-04
在VC++编程环境中，多线程技术是一种提升程序性能的重要手段。它允许程序同时执行多个任务，从而提高CPU利用率和程序响应速度。然而，多线程编程也带来了数据同步和线程通信的问题，以防止数据冲突和竞态条件。本...
C++多线程----线程安全
weixin_43956732的博客
11-17 9192
C++多线程----线程安全同时访问一个数据示例采用互斥锁mutex采用原子原子操作atomic 当使用多线程时，可能存在同时访问一个变量，导致变量被污染问题，所以需要通过编程克服这个问题。 同时访问一个数据示例 采用多个线程，分别记数，然后查看最终计算结果，代码如下： #include <iostream> #include <thread> #include <time.h> //计数全局变量 long cnt = 0; //计数程序 void counter()
多线程-线程锁-while循环
qq_40443457的博客
12-04 4040
今天写多线程遇到了几个问题，导致程序一直无法正常运行： 多个线程共用一个函数的时候，，由于没有用线程锁，导致无法正常运行； 函数中有while循环，加入多线程之后，，由于没有进行初始化互斥量，导致只有第一个线程起作用。 下面是例子： #include <stdio.h> #include <stdlib.h> #include <pthread.h> #in...
430.428.JAVA基础教程_多线程-线程的生命周期(430).rar
11-09
Java编程语言中的多线程是其强大的特性之一，它允许程序同时执行多个任务，从而提高系统效率和响应性。在Java中，理解线程的生命周期是掌握多线程编程的关键。线程的生命周期包含了五个主要状态：新建、就绪、运行、...
线程池优化多线程
weixin_42677025的博客
08-24 287
一、spring中已经实现的线程池： 1. SimpleAsyncTaskExecutor：不是真的线程池，这个类不重用线程，默认每次调用都会创建一个新的线程。 2. SyncTaskExecutor：这个类没有实现异步调用，只是一个同步操作。只适用于不需要多线程的地方。 3. ConcurrentTaskExecutor：Executor的适配类，不推荐使用。如果ThreadPoolTaskExecutor不满足要求时，才用考虑使用这个类。 4. SimpleThreadPoolTaskExecu
Java中的线程池优化
最新发布
微赚淘客系统开发者博客
07-27 429
通过合理设置核心线程数、最大线程数、任务队列和拒绝策略，并且持续监控和调整线程池的状态，可以在不同的负载条件下保持线程池的高效运行。核心线程数决定了线程池的基础线程数量，而最大线程数限制了线程池能够创建的线程数量。本文将详细探讨线程池的优化策略，涉及线程池的基本概念、常见问题及其解决方案，并通过具体代码示例来说明优化的实现方式。如果任务间隔时间较短，可以设置较短的空闲时间，以减少线程的创建和销毁开销。通过定期检查线程池的状态，如活跃线程数、任务队列长度等，可以及时调整线程池的配置，以适应变化的负载。
JAVA线程池如何调优
热门推荐
Venus's Blog
08-16 1万+
在JAVA中，线程可以使用定制的代码来管理，应用也可以利用线程池。在使用线程池时，有一个因素非常关键：调节线程池的大小对获得最好的性能至关重要。线程池的性能会随线程池大小这一基本选择而有所不同，在某些条件下，线程池过大对性能也有很多不利的影响。 所有线程池的工作方式本质是一样的：有一个任务队列，一定数量的线程会从该任务队列获取任务然后执行。任务的结果可以发回客户端，或保存到数据库，或保存到某个内部数据结构中，等等。但是在执行完任务后，这个线程会返回任务队列，检索另一个任务并执行。 线程池有最小线程数和最大线
Java多线程之线程池调优
yjc0403的博客
11-21 559
Java多线程之线程池调优   默认配置   corePoolSize=1 queueCapacity=Integer.MAX_VALUE maxPoolSize=Integer.MAX_VALUE keepAliveTime=60s allowCoreThreadTimeout=false rejectedExecutionHandler=AbortPolicy() ...
Java线程池及调优
HY1273383167的博客
04-08 2058
1. Java的线程池 ① 合理使用线程池的好处 Java的线程池是运用场景最多的并发框架，几乎所有需要异步或者并发执行任务的程序都可以使用线程池。 合理使用线程池能带来的好处： 降低资源消耗。 通过重复利用已经创建的线程降低线程创建的和销毁造成的消耗。例如，工作线程Woker会无线循环获取阻塞队列中的任务来执行。 提高响应速度。 当任务到达时，任务可以不需要等到线程创建就能立即执行。 提高线程的可管理性。 线程是稀缺资源，Java的线程池可以对线程资源进行统一分配、调优和监控。 ② 线
Java | 多线程调优（上）：哪些操作导致了上下文切换？
sinat_27143551的博客
10-25 2826
我们常说“实践是检验真理的唯一标准”，这句话不光在社会发展中可行，在技术学习中也同样适用。记得我刚入职上家公司的时候，恰好赶上了一次抢购活动。这是系统重构上线后经历的第一...
java线程池调优小技巧
Ye_Xing_的博客
07-06 763
java线程调优小技巧
多线程之线程池实现---加优化
修国栋的博客
08-20 237
预备知识 线程概念 main函数和信号处理函数是同一个进程地址空间中的多个控制流程,多线程也是如此. 信号处理函数的控制流程指示在信号递达时产生,在处理完信号之后结束.而多线程的控制流程可以长期并存,操作系统在各个线程之间调度和切换. 同一进程的多个线程共享同一地址空间,因此,代码段,数据段都是共享的,只有栈是私有的. 头文件 #include <pthread.h> 在Linux下封装好的线程函数，通过 g++ ***.cpp -lpthread -o xxx 编译，./xxx 运行 win
Java中的线程池调优与性能提升技巧
微赚淘客开发者博客
07-16 461
在Java并发编程中，线程池是一个非常重要的工具，它能够帮助我们管理线程的创建和销毁，提高系统的并发性能。通常，核心线程数设置为CPU核心数的2倍，以确保CPU资源的充分利用。在实际应用中，需要根据具体的业务需求和系统资源，动态调整线程池的参数，结合监控和调试工具，持续优化线程池的性能。线程池是一种多线程处理形式，通过提前创建一组线程来处理任务，从而避免了频繁创建和销毁线程的开销。在这个示例中，我们根据服务器的CPU核心数设置了核心线程数和最大线程数，选择了有界队列。工具类来创建各种类型的线程池。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值