JAVA----多线程

最新推荐文章于 2023-08-31 18:09:45 发布
最新推荐文章于 2023-08-31 18:09:45 发布
阅读量201 收藏
点赞数
分类专栏： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45629699/article/details/118786594
版权

JAVA多线程

  • 程序是指令和数据 的集合

  • 进程是执行程序的一次执行过程，是系统资源分配的单位

  • 进程包含多个线程，一个进程至少包含一个线程，线程是CPU调度和执行的单位

在这里插入图片描述

核心概念

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

三种创建方式

继承Tread类（重点）
public class TestThread extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 200; i++) {
            System.out.println("TestThread.run: "+i);
        }
    }

    public static void main(String[] args) {

        TestThread testThread = new TestThread();
        //开启线程
        testThread.start();

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

    }
}

在这里插入图片描述

线程不一定立即执行，CPU安排调度

实现Runnable接口（重点）
public class TestThread implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 200; i++) {
            System.out.println("TestThread.run: "+i);
        }
    }

    public static void main(String[] args) {

        TestThread testThread = new TestThread();
        //开启线程
        new Thread(testThread).start();

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

    }
}

在这里插入图片描述

龟兔赛跑例子：

public class TestThread3 implements Runnable {
    private String winner;

    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {

            if (Thread.currentThread().getName().equals("兔子") && i % 10 == 0) {
                try {
                    Thread.sleep(2);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            boolean flag = check(i);
            if (flag) {
                break;
            }
            System.out.println(Thread.currentThread().getName() + "=====>跑了" + i + "步");
        }
    }

    public boolean check(int step) {
        if (winner != null) {
            return true;
        } else if (step >= 100) {
            winner = Thread.currentThread().getName();
            System.out.println("winner is" + winner);
            return true;
        }
        return false;
    }

    public static void main(String[] args) {
        TestThread3 testThread3 = new TestThread3();
        new Thread(testThread3, "兔子").start();
        new Thread(testThread3, "乌龟").start();
    }

}


乌龟=====>跑了93步
乌龟=====>跑了94步
乌龟=====>跑了95步
乌龟=====>跑了96步
兔子=====>跑了1步
乌龟=====>跑了97步
乌龟=====>跑了98步
乌龟=====>跑了99步
兔子=====>跑了2步
winner is乌龟
实现Callable接口

图片下载器

public class TestCollable implements Callable<Boolean> {
    private String url;
    private String name;

    public TestCollable(String url, String name) {
        this.url = url;
        this.name = name;
    }
    @Override
    public Boolean call()  {
        WebDownloader2 webDownloader = new WebDownloader2();
        webDownloader.downLoader(url, name);
        System.out.println(name);
        return false;
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        TestCollable t1 = new TestCollable("http://nimg.ws.126.net/?url=http%3A%2F%2Fdingyue.ws.126.net%2F2021%2F0524%2F23d33360j00qtkixi0065c000qo0140c.jpg&thumbnail=650x2147483647&quality=80&type=jpg", "1.jpg");
        TestCollable t2 = new TestCollable("https://gimg2.baidu.com/image_search/src=http%3A%2F%2Finews.gtimg.com%2Fnewsapp_match%2F0%2F12070081997%2F0.jpg&refer=http%3A%2F%2Finews.gtimg.com&app=2002&size=f9999,10000&q=a80&n=0&g=0n&fmt=jpeg?sec=1627736036&t=6a487c9cfc9954360ca08a2b1a35c08b", "2.jpg");
        TestCollable t3 = new TestCollable("https://gimg2.baidu.com/image_search/src=http%3A%2F%2Finews.gtimg.com%2Fnewsapp_match%2F0%2F6311385436%2F0.jpg&refer=http%3A%2F%2Finews.gtimg.com&app=2002&size=f9999,10000&q=a80&n=0&g=0n&fmt=jpeg?sec=1627736036&t=db6580ea15875a49d9b9bdc115dd4d3e", "3.jpg");
        TestCollable t4 = new TestCollable("http://p4.ssl.cdn.btime.com/t0107f73bda6cf546d0.jpg", "04.jpg");

        ExecutorService ser = Executors.newFixedThreadPool(4);
        Future<Boolean> r1 = ser.submit(t1);
        Future<Boolean> r2 = ser.submit(t2);
        Future<Boolean> r3 = ser.submit(t3);
        Future<Boolean> r4 = ser.submit(t4);

        boolean res1 = r1.get();
        boolean res2 = r2.get();
        boolean res3 = r3.get();
        boolean res4 = r4.get();
        System.out.println("res1 = " + res1);
        System.out.println("res2 = " + res2);
        System.out.println("res3 = " + res3);
        System.out.println("res4 = " + res4);
        ser.shutdownNow();
    }
}
class WebDownloader2 {

    public void downLoader(String url, String name) {
        try {
            FileUtils.copyURLToFile(new URL(url), new File(name));
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("IO异常：downLoader ");
        }
    }
}

Lambda表达式

lambda表达式实现需要一个函数式接口

**函数式接口：**只有一个抽象方法的接口

//函数式接口
interface InterfaceFunction(){
    abstract void a();
}

lambda表达式无参实现

public class B{
    
    public static void main(String []arg){
        InterfaceFunction interfaceFunction = null;
        interfaceFunction = ()->{
            System.out.println("我是lambda表达式!!!")
        }
    }
}

lambda表达式有参实现

public class B{
    
    public static void main(String []arg){
        InterfaceFunction interfaceFunction = null;
        //方式一：
         interfaceFunction = (a)->{  
            System.out.println("我是lambda表达式!!!");
        }
        //方式二:简化小括号
        interfaceFunction = a->{  
            System.out.println("我是lambda表达式!!!");
        }
        
        //方式三：简化花括号
        interfaceFunction = a -> System.out.println("我是lambda表达式!!!");
    }
    //总结：1、只有当lambda表达式里面只有一行代码时方可简化花括号
    //     2、前提是函数式接口
    //	   3、当有多个参数时，不能省略小括号
    
}
//函数式接口
interface InterfaceFunction(){
    abstract void a(int a);
}

线程的状态

在这里插入图片描述
在这里插入图片描述

线程方法
方法说明
setPriority(int newPriority)更改线程的优先级
static void sleep(long millis)在指定的毫秒数内让当前正在执行的线程休眠
void join()等待该线程终止
static void yield()暂停当前正在执行的线程对象，并执行其他线程
void interrupt()中断线程，别用这个方式
boolean isAlive（）测试线程是否处于活动状态
停止线程
  • 不在推荐使用JDK提供的stop()、destroy()方法，这两个方法已经废弃
  • 推荐线程自己停止下来
  • 建议使用一个标志位（flag）进行线程终止
public class TestThread4 implements Runnable{

    //标志位
    private boolean flag = true;

    @Override
    public void run() {
        while (flag){
            System.out.println("TestThread4.run");
        }
    }

    public void stop(){
        this.flag = false;
    }

    public static void main(String[] args) {

        TestThread4 testThread4 = new TestThread4();
        new Thread(testThread4).start();

        for (int i = 0; i < 1000; i++) {
            System.out.println("main ===> i = " + i);
            if (i==900){
                testThread4.stop();
                System.out.println("ruan线程已停止");
            }
        }
    }
}
线程休眠
  • sleep（时间）指定当前线程阻塞的毫秒数；
  • sleep存在异常InterruptedException；
  • sleep时间达到后线程进入就绪状态
  • sleep可以模拟网络延时，倒计时等。
  • 每一个对象都有一个锁，sleep不会释放锁；
线程礼让
  • 礼让线程，让当前正在执行的线程暂停，但不阻塞
  • 将线程从运行状态转为就绪状态
  • 让CPU重新调度，礼让不一定成功！线程A礼让了线程B，但当CPU再次调度的时候，又调度A线程
public class TestYield {
    public static void main(String[] args) {
        MyYield myYield = new MyYield();
        new Thread(myYield,"A").start();
        new Thread(myYield,"B").start();
    }
}

class MyYield implements Runnable {

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"线程开始");
         Thread.yield();//线程礼让
        System.out.println(Thread.currentThread().getName()+"线程结束");
    }
}
join
  • join合并线程，待此线程执行完成后，再执行其他线程，其他线程阻塞
  • 可以想象成插队
public class TestJoin implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("Vip线程===" + i);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        TestJoin testJoin = new TestJoin();
        Thread thread = new Thread(testJoin);
        thread.start();

        for (int i = 0; i < 30; i++) {
            if (i == 10) {
                thread.join();
            }
            System.out.println("TestJoin.main主线程 ===" + i);

        }
    }
}
观察线程状态

  • 线程状态。线程可以处于以下状态之一：

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

    一个线程可以在给定时间点处于一个状态。 这些状态是不反映任何操作系统线程状态的虚拟机状态。

      
  Thread thread = new Thread(()->{
      
      for(int i=0;i<5;i++){
          try{
              thread.sleep(1000);
          }catch (InterruptedException e) {
                  e.printStackTrace();
          }
      }
      System.out.println("==========");
  });
  
  
  Thread.State state = thread.getState();
  Systemp.out.println("state1 ="+state);
  
  thread.start();
  state = thread.getState();
  System.out.println("state2 ="+state);
  
  while(state != Thread.State.TERMINATED){
      thread.sleep(100);
      state = thread.getState();
       System.out.println("state3 ="+state);
  }
  
  thread.start();//线程死亡后就不能再次开启线程，否则会报错java.lang.IllegalThreadStateException

}

state 1 = NEW
state 2 = RUNNABLE
state 3 = TIMED_WAITING
state 3 = TIMED_WAITING
state 3 = TIMED_WAITING
state 3 = TIMED_WAITING
state 3 = TIMED_WAITING
state 3 = TIMED_WAITING
state 3 = TERMINATED
``

在这里插入图片描述

线程优先级
  • Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度器按照优先级决定应该调度那个线程来执行。
  • 线程的优先级用数字表示，范围从1~10.
    • Thread.MIN_PRIORITY = 1;
    • Thread.MAX_PRIORITY = 10;
    • Thread.NORM_PRIORITY = 5;
  • 改变或获取优先级方式
    • getPriority()
    • setPriority(int xxx)
public class TestPriority {
    public static void main(String[] args) {
        //主线程
        System.out.println(Thread.currentThread().getName()+"====:"+Thread.currentThread().getPriority());

        MyPriority myPriority = new MyPriority();
        Thread t0 = new Thread(myPriority);
        Thread t1 = new Thread(myPriority);
        Thread t2 = new Thread(myPriority);
        Thread t3 = new Thread(myPriority);

        t0.start();

        //优先级的设置再开启线程之前设置
        t3.setPriority(Thread.MAX_PRIORITY);
        t3.start();

        t1.setPriority(1);
        t1.start();

        t2.setPriority(4);
        t2.start();


    }
}
class MyPriority implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"====:"+Thread.currentThread().getPriority());
    }
}

运行结果
在这里插入图片描述
在这里插入图片描述
注意：

  • 优先级高的不一定先执行
  • 优先级低只是意味着获得调度的概率低，并不是优先级低就不会被调用。这都是看CPU的调度心情
守护线程
  • 线程分为用户线程和守护线程
  • 虚拟机必须确保用户线程执行完毕
  • 虚拟机不用等待守护线程执行完毕，如后台记录操作日志，垃圾回收等待

只要当前JVM实例中尚存在任何一个非守护线程没有结束，守护线程就全部工作；只有当最后一个非守护线程结束时，守护线程随着JVM一同结束工作。

public class TestDaemon {
    public static void main(String[] args) {
        God god = new God();
        You you = new You();

        Thread thread = new Thread(god);
        //setDaemon默认为false，即用户线程，为true为守护线程，设置须在开启线程之前
        thread.setDaemon(true);
        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("++++++goodBy world++++++");
    }
}
}

线程同步

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

处理多线程问题时，多个线程访问同一个对象，并且某些对象还想要修改这个对象，这时候我们就需要线程同步，线程同步其实就是一种等待机制，多个需要同时访问此对象的线程进入这个对象的等待池形成队列，等待前面线程使用完毕，下一个线程再使用

**形成条件：**队列+锁

由于同意进程的多个线程共享同一块存储空间，在带来方便的同时，也带来访问冲突的问题，为了保证数据在方法中被访问时的正确性，在访问时加入**锁机制** synchronized ，当一个线程获得对象的排他锁，独占资源，其他线程必须等待，使用后释放锁即可

存在问题：
  • 一个线程持有锁会导致其他所有需要此锁的线程挂起；
  • 在多线程竞争下，加锁，释放锁会导致比较多的上下文切换 和 调度延时，引起性能问题；
  • 如果一个优先级高的线程等待一个优先级低的线程释放锁 会导致优先级倒置，引起性能问题。
同步块
  • 同步块：synchronized（Obj）{ }
  • Obj称之为同步监视器
    • Obj可以是任何对象，但是推荐使用共享资源作为同步监视器(增删改查的对象)
    • 同步方法中无需指定同步监视器，因为同步方法的同步监视器就是this就是这个对象本身，或者是class
  • 同步监视器的执行过程
    • 第一个线程访问，锁定同步监视器，执行其中代码
    • 第二个线程访问，发现同步监视器被锁定，无法访问
    • 第一个线程访问完毕，解锁同步监视器
    • 第二个线程访问，发现同步监视器没有锁，然后锁定并访问
同步方法——买票
public class UnsafeTickte {

    public static void main(String[] args) {
        BuyTicket station = new BuyTicket();
        new Thread(station,"张三").start();
        new Thread(station,"李四").start();
        new Thread(station,"王五").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(100);
        System.out.println(Thread.currentThread().getName()+"拿到了"+ticketNums--);
    }
}

在这里插入图片描述

同步代码块——取钱
public class UnsafeMoney {
    public static void main(String[] args) {
        Account account = new Account(400, "公积金");
        Drawing you = new Drawing(account, 50, "你");
        Drawing wef = new Drawing(account, 100, "妻子");
        you.start();
        wef.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 drawMoney;
    int nowMoney;

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

    @Override
    public void run() {

        synchronized (account){
            if (account.money - drawMoney < 0) {
                System.out.println(Thread.currentThread().getName() + "钱不够，取不了");
                return;
            }

            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

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

    }
}

在这里插入图片描述

死锁

某一个同步代码块同时拥有“两个以上对象的锁”时，就可能会发生死锁

死锁避免方法

  • 产生死锁的四个必要条件：

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

  • 如何避免死锁：

    • 只需破以上所列出的任意一个或多个条件就可以避免死锁发生
Lock（锁）
  • JDK5开始，Java提供了显式定义同步锁对象实现同步。同步锁使用Lock对象充当
  • java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象
  • **Reentrant Lock（可重入锁）**类实现了Lock，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是Reentrant Lock，可以显式加锁，释放锁。
public class TestLock {
    public static void main(String[] args) {
        Locks locks = new Locks();
        new Thread(locks).start();
        new Thread(locks).start();
        new Thread(locks).start();
    }
}

class Locks implements Runnable {

    private int tickets = 10;
    private final ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {

        while (true) {

            try {
                lock.lock();
                
                if (tickets > 0) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("tickets = " + tickets--);
                } else {
                    break;
                }
            } finally {
                lock.unlock();
            }


        }

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

线程通信

synchronized可阻止并发更新同一个共享资源，实现同步；但不能用来实现不同线程之间的消息传递（通信）

Java提供了几个方法解决线程之间的通信问题

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

注意：均是Object类的方法，都只能在同步方法或者同步代码块中使用，否则会抛出异常

解决方式
一：管程法——生产者消费者模式
public class TestPC {
    public static void main(String[] args) {
        SynContainer container = new SynContainer();
         new product(container).start();
         new Constructor(container).start();
    }
}

//产品 炸鸡
class Chicken {
    int id;

    public Chicken(int id) {
        this.id = id;
    }
}

//生产者
class product extends Thread {

    SynContainer container;

    public product(SynContainer container) {
        this.container = container;
    }

    @Override
    public void run() {

        for (int i = 0; i < 100; i++) {
            container.push(new Chicken(i));
            System.out.println("生产了" + i + "炸鸡");
        }
    }
}

//消费者
class Constructor extends Thread {
    SynContainer container;

    public Constructor(SynContainer container) {
        this.container = container;
    }

    @Override
    public void run() {

        for (int i = 0; i < 100; i++) {
            System.out.println("消费了" + container.pop().id + "炸鸡");
        }
    }
}

//缓冲区
class SynContainer {

    Chicken[] chickens = new Chicken[10];
    int count = 0;

    //生产者生产产品
    public synchronized void push(Chicken chicken) {

        //如果容器满了，就需要等待消费
        if (count == chickens.length) {
            //通知消费者消费
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        //如果没有满，就生产
        chickens[count] = chicken;
        count++;

        //通知消费者消费
        this.notifyAll();
    }

    //消费者消费产品
    public synchronized Chicken pop() {
        
        if (count == 0) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        count--;
        Chicken chicken = chickens[count];
        this.notifyAll();
        return chicken;
    }

}
二：信号灯法（标志位）——演员观众
public class TestTV{
    public static void main(String[] args){

        TV tv = new TV();
        new Player(tv).start();
        new Watch(tv).start();
    }
}

//演员
class Player extends Thread{
    TV tv;
    public Player(TV tv){
        this.tv = tv;
    }
    @Override
    public void run(){
        for(int i=0;i<20;i++){
            //一半节目一半广告
            if(i%2==0){
                tv.play("《王爷到》");
            }else{
                tv.play("广告");
            }
        }
    }

}
//观众
class Watch extends Thread{
    TV tv;
    public Watch(TV tv){
        this.tv = tv;
    }
    @Override
    public void run(){
        for(int i=0;i<20;i++){
            tv.see();
        }
    }
}
//节目
class TV{
    //节目名
    private  String name;
    //标志
    private boolean flag = true;

    //表演方法
    public synchronized void play(String name){
        if(!flag){
            try{
                this.wait();
            }catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("表演了："+name);
        this.notifyAll();
        this.name = name;
        this.flag = !this.flag;
    }
    //观看方法
    public synchronized void see(){
        if(flag){
            try{
                this.wait();
            }catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("观看了："+name);
        this.notifyAll();
        this.flag = !this.flag;

    }
}
线程池
  • 背景：经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大
  • **思路：**提前创建好多个线程，放入线程池中，使用时直接获取，使用完毕放回池中。可以避免频繁创建销毁、实现重复利用。类比共享单车
  • 好处：
    • 提高响应速度（减少了创建新线程的时间）
    • 降低资源消耗（重复利用线程池中的线程，不需要每次都创建）
    • 便于线程管理
      • corePoolSize:核心池的大小
      • maximumPoolSize:最大线程数
      • keepAliveTime：线程没有任务时最多保持多长时间后终止

在这里插入图片描述
在这里插入图片描述

南疆晚歌
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
10个线程同步处理1000行消息
weixin_30511107的博客
12-28 858
多线程，并发，是经常遇到的问题，平时解决的方案也想过很多，比如说现在有1000行消息，需要开10个线程同时处理。 之前想过两个方案： 方案一： 一次开10个线程，每个线程处理一条消息，等10个线程全部处理结束之后，再开启下10个线程，直到全部处理完毕 缺陷：需要等待其他n - 1个线程结束后，才能同时启动下n个线程 方案二： 将1000行消息分割为10份，每100行用一个...
JAVA-多线程 所有文件
01-09
JAVA-多线程 所有文件
java多线程实现大批量数据导入源码
09-29
java多线程实现大批量数据切分成指定份数的数据，然后多线程处理入库或者导出，线程的个数和每份数据的数量都可以控制
JAVA多线程10个线程处理1000个数据
热门推荐
xiaobao5214的博客
11-06 1万+
import java.util.ArrayList; import java.util.List; import java.util.concurrent.CountDownLatch; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class MultiT...
多线程实际运用（十个线程插入1000条数据）
q438944209的博客
10-26 3686
在实际运用中，利用多线程进行数据处理分担压力 此例子是模拟实际生产...
1000条数据开10个线程处理，每次处理50条CompletableFuture 实现
原&点、、
08-31 398
【代码】1000条数据开10个线程处理，每次处理50条CompletableFuture 实现。
java-多线程 test
06-11
java-多线程 test
Java-多线程连接池模型
07-22
多线程连接池模型
Java多线程-多线程相关概念
最新发布
01-19
Java多线程--多线程相关概念
Java-多线程线程状态转换图
07-22
多线程线程状态转换图
java 1000个线程_java随机产生的1000个数字，放在数组中，用10个线程进行查询这1000个数字中66的下标...
weixin_29014939的博客
02-16 180
展开全部publicclassArrThreadDemo{publicstaticvoidmain(String[]args){62616964757a686964616fe58685e5aeb931333335316539for(inti=0;inewThread(newDemo()).start();}}}classDemoimplementsRunnable{...
Java并发编程之CountDownLatch
xuzhiyongcsdnper
05-14 285
Java并发编程之CountDownLatch
Java多线程经典的4道笔试题---含多种实现方式
自律使我自由
11-07 3031
1、按序输出 同时启动三个线程，分别为A、B、C，其中A线程打印“a”，B线程打印“b”，C线程打印“c”，要求按照abc顺序打印输出。 第一种方式 使用join实现，join方法表示调用线程必须等待该线程执行完成后才能继续往下执行。 public class SortPrint { public static void main(String[] args) throws InterruptedException { SortPrint sortPrint = new SortP
创建多个线程处理数据库中多条数据
chenxingde的博客
02-18 2302
处理思路：（1）比如查出100万数据（2）：创建10个线程，循环处理这些数据，每一次处理调用一个线程，如果某一个线程被占用了，那么就调用另外一个线程，以此类推，这样就不需要等待上一个线程的完毕，从而加快处理的速度。 //需要引用的线程类：这个是jdk1.8自带的线程处理jia包 import java.util.concurrent.ExecutorService; @Controller @Re...
多线程跑批处理大数据代码总结
damoneric_guo的博客
02-24 2022
多线程跑批处理大数据 具体思路：是先把大量数据（100w）按照1000切分成多份，然后把1000个数据排序放在10个线程中，进行多线程处理。 public void handle() throws BusinessException { int pageSize = 1000; // 目前处理逻辑中，存在多线程并发，故保险起见线程数设置不要超过10 int threadNum = 10; Page<PDto> page = new Page<PDto
多线程基础学习
05-22 509
1) 什么是线程？ 线程是操作系统能够进行运算调度的最小单位，它被包含在进程之中，是进程中的实际运作单位。程序员可以通过它进行多处理器编程，你可以使用多线程对 运算密集型任务提速。比如，如果一个线程完成一个任务要100毫秒，那么用十个线程完成改任务只需10毫秒。Java在语言层面对多线程提供了卓越的支 持，它也是一个很好的卖点。欲了解更多详细信息请点击这里。 2) 线程和进程有什么区...
JAVA-多线程模拟处理大量数据
ZHENCONG_STAR的博客
11-26 5165
此处业务场景，可想象为，有大批量的数据，需要添加到数据库   import java.util.ArrayList; import java.util.List; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.lock...
java使用多线程及分页查询数据量很大的数据
szzssz的博客
07-24 1万+
主要的思路就是： 先通过count查出结果集的总条数，设置每个线程分页查询的条数，通过总条数和单次条数得到线程数量，通过改变limit的下标实现分批查询。   调用方法： import org.springframework.beans.factory.annotation.Autowired; import java.util.ArrayList; import java.util....
java多线程 传递参数 启动50个线程，每个线程处理10条数据
zhengTornado的博客
08-10 2339
无参数的多线程 每个线程处理10条数据 package org.jeecg.modules.gybmapi; public class ThreadTask implements Runnable{ public void run() { for (int i = 0; i < 10; i++) { System.out.println(Thread.currentThread().getName() + "执行" + i); } } } 启动50个线程 package
jmu-java-07多线程-thread
03-16
JMU Java 07 多线程 (Thread) 是指在 Java 语言中使用多个线程来同时执行多个任务的技术。通过使用多线程，可以提高程序的并行处理能力，加快程序的执行速度，提高程序的效率。在 Java 中，多线程可以通过继承 java....

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

南疆晚歌

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

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

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

打赏作者

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

抵扣说明：

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

余额充值