Java 多线程编程

最新推荐文章于 2024-10-30 17:17:38 发布
最新推荐文章于 2024-10-30 17:17:38 发布
阅读量531 收藏
点赞数 1
分类专栏： java se进阶学习 文章标签： 面试 职场和发展 java 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43536259/article/details/121327149
版权

Java 多线程编程

程序(program) 是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。

进程(process) 是程序的一次执行过程，或是正在运行的一个程序。是一个动态 的过程：有它自身的产生、存在和消亡的过程。——生命周期

  • 如：运行中的QQ，运行中的MP3播放器
  • 程序是静态的，进程是动态的
  • 进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域

线程(thread)，进程可进一步细化为线程，是一个程序内部的一条执行路径。

  • 若一个进程同一时间并行执行多个线程，就是支持多线程的
  • 线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器(pc)，线程切换的开 销小
  • 一个进程中的多个线程共享相同的内存单元/内存地址空间它们从同一堆中分配对象，可以 访问相同的变量和对象。这就使得线程间通信更简便、高效。但多个线程操作共享的系统资 源可能就会带来安全的隐患。

Java 给多线程编程提供了内置的支持。 一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。

多线程是多任务的一种特别的形式，但多线程使用了更小的资源开销。

这里定义和线程相关的另一个术语 - 进程：一个进程包括由操作系统分配的内存空间，包含一个或多个线程。一个线程不能独立的存在，它必须是进程的一部分。一个进程一直运行，直到所有的非守护线程都结束运行后才能结束。

多线程能满足程序员编写高效率的程序来达到充分利用 CPU 的目的。

单核CPU和多核CPU的理解

  • 单核CPU，其实是一种假的多线程，因为在一个时间单元内，也只能执行一个线程的任务。例如：虽然有多车道，但是收费站只有一个工作人员在收费，只有收了费 才能通过，那么CPU就好比收费人员。如果有某个人不想交钱，那么收费人员可以 把他“挂起”（晾着他，等他想通了，准备好了钱，再去收费）。但是因为CPU时间单元特别短，因此感觉不出来。
  • 如果是多核的话，才能更好的发挥多线程的效率。（现在的服务器都是多核的）
  • 一个Java应用程序java.exe，其实至少有三个线程：main()主线程，gc() 垃圾回收线程，异常处理线程。当然如果发生异常，会影响主线程。

并行与并发

  • 并行：多个CPU同时执行多个任务。比如：多个人同时做不同的事。
  • 并发：一个CPU(采用时间片)同时执行多个任务。比如：秒杀、多个人做同一件事。

何时需要多线程 ?

  • 程序需要同时执行两个或多个任务。
  • 程序需要实现一些需要等待的任务时，如用户输入、文件读写 操作、网络操作、搜索等。
  • 需要一些后台运行的程序时。

一个线程的生命周期

线程是一个动态执行的过程，它也有一个从产生到死亡的过程。

下图显示了一个线程完整的生命周期。

  • 新建状态:

    使用 new 关键字和 Thread 类或其子类建立一个线程对象后，该线程对象就处于新建状态。它保持这个状态直到程序 start() 这个线程。

  • 就绪状态:

    当线程对象调用了start()方法之后，该线程就进入就绪状态。就绪状态的线程处于就绪队列中，要等待JVM里线程调度器的调度。

  • 运行状态:

    如果就绪状态的线程获取 CPU 资源，就可以执行 run()，此时线程便处于运行状态。处于运行状态的线程最为复杂，它可以变为阻塞状态、就绪状态和死亡状态。

  • 阻塞状态:

    如果一个线程执行了sleep（睡眠）、suspend（挂起）等方法，失去所占用资源之后，该线程就从运行状态进入阻塞状态。在睡眠时间已到或获得设备资源后可以重新进入就绪状态。可以分为三种：

    • 等待阻塞：运行状态中的线程执行 wait() 方法，使线程进入到等待阻塞状态。

    • 同步阻塞：线程在获取 synchronized 同步锁失败(因为同步锁被其他线程占用)。

    • 其他阻塞：通过调用线程的 sleep() 或 join() 发出了 I/O 请求时，线程就会进入到阻塞状态。当sleep() 状态超时，join() 等待线程终止或超时，或者 I/O 处理完毕，线程重新转入就绪状态。

  • 死亡状态:

    一个运行状态的线程完成任务或者其他终止条件发生时，该线程就切换到终止状态。

线程的优先级

  • 每一个 Java 线程都有一个优先级，这样有助于操作系统确定线程的调度顺序

  • Java 线程的优先级是一个整数，其取值范围是 1 （Thread.MIN_PRIORITY ） - 10 （Thread.MAX_PRIORITY ）

  • 默认情况下，每一个线程都会分配一个优先级 NORM_PRIORITY（5）

  • 可以通过getPriority()来获取当前线程的优先级

  • 也可以通过setPriority(int newPriority)来改变线程的优先级

具有较高优先级的线程对程序更重要，并且应该在低优先级的线程之前分配处理器资源。但是，线程优先级不能保证线程执行的顺序，而且非常依赖于平台。

创建一个线程

Java 提供了三种创建线程的方法：

  • 通过实现 Runnable 接口；
  • 通过继承 Thread 类本身；
  • 通过 Callable 和 Future 创建线程。

1. 通过实现 Runnable 接口来创建线程

创建一个线程，最简单的方法是创建一个实现 Runnable 接口的类。

为了实现 Runnable，一个类只需要执行一个方法调用 run()，声明如下：

public  void  run()

你可以重写该方法，重要的是理解的 run() 可以调用其他方法，使用其他类，并声明变量，就像主线程一样。

在创建一个实现 Runnable 接口的类之后，你可以在类中实例化一个线程对象。

Thread 定义了几个构造方法，下面的这个是我们经常使用的：

Thread(Runnable  threadOb,String  threadName);

这里，threadOb 是一个实现 Runnable 接口的类的实例，并且 threadName 指定新线程的名字。

新线程创建之后，你调用它的 start() 方法它才会运行。

void  start();

###　方式：

实现Runnable接口

  • 定义子类，实现Runnable接口。

  • 子类中重写Runnable接口中的run方法。

  • 创建Runnable子类的对象

  • 将Runnable接口的子类对象作为实际参数传递给Thread类的构造器中。

  • 调用Thread类的start方法：开启线程，调用Runnable子类接口的run方法。

下面是一个创建线程并开始让它执行的实例：

实例

ThreadTest1文件：

/**
 * 方式二：使用 Runnable 接口实现
 * 1.定义子类，实现Runnable接口。
 * 2.子类中重写Runnable接口中的run方法。
 * 3.创建Runnable子类的对象。
 * 4.将Runnable接口的子类对象作为实际参数传递给Thread类的构造器中。
 * 5.调用Thread类的start方法：开启线程，调用Runnable子类接口的run方法。
 * @author Token
 * @create 2021-11-13 21:50
 */
public class ThreadTest1{
    public static void main(String[] args) {
        //3.通过Thread类含参构造器创建线程对象。
        Runnable m1 = new myThread();

        //4.将Runnable接口的子类对象作为实际参数传递给Thread类的构造器中。
        Thread t1 = new Thread(m1);
        //5.调用Thread类的start方法：开启线程，调用Runnable子类接口的run方法。
        t1.start();
    }

}

myThread文件：

//1.定义子类，实现Runnable接口。
class myThread implements Runnable{

    //2.子类中重写Runnable接口中的run方法。
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0 ){
                System.out.println(i);
            }
        }
    }
}

编译以上程序运行结果如下：

image-20211113220148877

需要创建第二个线程时，只需要再次创建一个Thread对象(参数可以是同一个Runnable对象)接口

Thread t2 = new Thread(m1);
//5.调用Thread类的start方法：开启线程，调用Runnable子类接口的run方法。
t2.start();

2. 通过继承Thread来创建线程

创建一个线程的第二种方法是创建一个新的类，该类继承 java.lang.Thread 类，然后创建一个该类的实例。

继承类必须重写 run() 方法，该方法是新线程的入口点。它也必须调用 start() 方法才能执行。

该方法尽管被列为一种多线程实现方式，但是本质上也是实现了 Runnable 接口的一个实例。

方式：

  1. 创建一个继承于Thread类的子类
  2. 重写Thread类的run()方法，将此线程执行的操作声明在run()中
  3. 创建Thread类的子类对象
  4. 通过此对象调用start()方法，start()的作用：1. 启动当前线程 2. 调用当前线程的run（）

注意点

  1. 如果自己手动调用run()方法，那么就只是普通方法，没有启动多线程模式。
  2. run()方法由JVM调用，什么时候调用，执行的过程控制都有操作系统的CPU 调度决定。
  3. 想要启动多线程，必须调用start方法。
  4. 一个线程对象只能调用一次start()方法启动，如果重复调用了，则将抛出以上 的异常“IllegalThreadStateException”。

###　Threaad类的构造器

  • Thread()：创建新的Thread对象
  • Thread(String threadname)：创建线程并指定线程实例名
  • Thread(Runnable target)：指定创建线程的目标对象，它实现了Runnable接 口中的run方法
  • Thread(Runnable target, String name)：创建新的Thread对象

实例

class ThreadDemo extends Thread {
   private Thread t;
   private String threadName;
   
   ThreadDemo( String name) {
      threadName = name;
      System.out.println("Creating " +  threadName );
   }
   
   public void run() {
      System.out.println("Running " +  threadName );
      try {
         for(int i = 4; i > 0; i--) {
            System.out.println("Thread: " + threadName + ", " + i);
            // 让线程睡眠一会
            Thread.sleep(50);
         }
      }catch (InterruptedException e) {
         System.out.println("Thread " +  threadName + " interrupted.");
      }
      System.out.println("Thread " +  threadName + " exiting.");
   }
   
   public void start () {
      System.out.println("Starting " +  threadName );
      if (t == null) {
         t = new Thread (this, threadName);
         t.start ();
      }
   }
}
 
public class TestThread {
 
   public static void main(String args[]) {
      ThreadDemo T1 = new ThreadDemo( "Thread-1");
      T1.start();
      
      ThreadDemo T2 = new ThreadDemo( "Thread-2");
      T2.start();
   }   
}

编译以上程序运行结果如下：

Creating Thread-1
Starting Thread-1
Creating Thread-2
Starting Thread-2
Running Thread-1
Thread: Thread-1, 4
Running Thread-2
Thread: Thread-2, 4
Thread: Thread-1, 3
Thread: Thread-2, 3
Thread: Thread-1, 2
Thread: Thread-2, 2
Thread: Thread-1, 1
Thread: Thread-2, 1
Thread Thread-1 exiting.
Thread Thread-2 exiting.

Thread 方法

下表列出了Thread类的一些重要方法：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dTJOYeoz-1636934095373)(D:\tongbu\我的坚果云\java\多线程知识_md_files\1_20211108143128.PNG?v=1&type=image&token=V1:HQvGXtamGeNvrM1A7icGTEF5_rs-imNkb54liB6Sfis)]

上述方法是被 Thread 对象调用的，下面表格的方法是 Thread 类的静态方法。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yDlJpmOo-1636934095377)(%E5%A4%9A%E7%BA%BF%E7%A8%8B%E7%9F%A5%E8%AF%86_md_files/2_20211108143147.PNG?v=1&type=image&token=V1:kzNQ3aWnYI8CII4Bx9W9dAJG7elgVwcjzkP0jxnUxvY)]

实例

windows 文件：

class windows extends Thread{
    private static int ticket = 100; //票
    @Override
    public void run() {

        while(true){
            if(ticket > 0){
                System.out.println(getName()+"卖票，票号为：" + ticket);
                ticket--;
            }else{
                break;
            }
        }

    }
}

WindowsTest 文件：

/**
 * 例子：创建三个售票窗口，总票数为100张
 * 线程安全问题，待解决
 * @author Token
 * @create 2021-11-13 21:18
 */
public class WindowsTest  extends Thread{
    public static void main(String[] args) {
        windows w1 = new windows();
        windows w2 = new windows();
        windows w3 = new windows();

        w1.setName("窗口1");
        w2.setName("窗口2");
        w3.setName("窗口3");

        w1.start();
        w2.start();
        w3.start();
    }

}

执行结果：

image-20211113214334653

但是此方法中存在卖重复票的问题！！！

通过Runnable 接口重写卖票窗口程序：

package com.exer;

/**
 * 线程安全问题，待解决
 * @author Token
 * @create 2021-11-13 22:08
 */
public class windowsTest2 {
    public static void main(String[] args) {
        Runnable m1 = new MyThread();

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

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

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

    }
}

class MyThread implements Runnable{
    private  int ticket = 100;//票
    @Override
    public void run() {
        while(true){
            if(ticket >0){
                System.out.println(Thread.currentThread().getName()+"卖票。票号：" + ticket);
                ticket--;
            }else{
                break;
            }

        }
    }
}

３.通过 Callable 和 Future 创建线程

    1. 创建 Callable 接口的实现类，并实现 call() 方法，该 call() 方法将作为线程执行体，并且有返回值。
    1. 创建 Callable 实现类的实例，使用 FutureTask 类来包装 Callable 对象，该 FutureTask 对象封装了该 Callable 对象的 call() 方法的返回值。
    1. 使用 FutureTask 对象作为 Thread 对象的 target 创建并启动新线程。
    1. 调用 FutureTask 对象的 get() 方法来获得子线程执行结束后的返回值。

实例

public class CallableThreadTest implements Callable<Integer> {
    public static void main(String[] args)  
    {  
        CallableThreadTest ctt = new CallableThreadTest();  
        FutureTask<Integer> ft = new FutureTask<>(ctt);  
        for(int i = 0;i < 100;i++)  
        {  
            System.out.println(Thread.currentThread().getName()+" 的循环变量i的值"+i);  
            if(i==20)  
            {  
                new Thread(ft,"有返回值的线程").start();  
            }  
        }  
        try  
        {  
            System.out.println("子线程的返回值："+ft.get());  
        } catch (InterruptedException e)  
        {  
            e.printStackTrace();  
        } catch (ExecutionException e)  
        {  
            e.printStackTrace();  
        }  
  
    }
    @Override  
    public Integer call() throws Exception  
    {  
        int i = 0;  
        for(;i<100;i++)  
        {  
            System.out.println(Thread.currentThread().getName()+" "+i);  
        }  
        return i;  
    }  
}

创建线程的三种方式的对比

  1. 采用实现 Runnable、Callable 接口的方式创建多线程时，线程类只是实现了 Runnable 接口或 Callable 接口，还可以继承其他类。

开发中：优先选择，实现Ｒunnable接口的方式

原因：1. 实现的方式没有类单继承的局限性

​ 2. 实现的方式更加适合来处理多个线程共享数据的情况

联系：public class Thread implement Runnable

相同点：两种方式都需要重写run()，将线程要执行的逻辑声明再run()中

  1. 使用继承 Thread 类的方式创建多线程时，编写简单，如果需要访问当前线程，则无需使用 Thread.currentThread() 方法，直接使用 this 即可获得当前线程。

线程的同步问题

  1. 问题：上述卖票过程中，出现了重票、错票问–>出现了线程的安全问题

  2. 出现的原因：当每个线程操作车票的过程中，尚未操作完成时，其他线程就进来了，也操作车票

  3. 如何解决：当一个线程 a 操作ticket的时候，其他线程不能参与进来，直到线程 a 操作完成ticket时，其他线程才开始操作ticket。这种情况即使线程 a 出现了阻塞，请其他线程也只能等待

  4. 再java中，我们使用同步机制，来解决线程的安全问题

    • 方式一：同步代码块

      synchronized(同步监视器){

	//需要被同步的代码

}

      说明：1. 操作同步代码块（共享数据）的代码，就是需要被同步的代码 -->不能包含代码多了，也不能包含代码 少了

      ​ 2.共享数据：多个线程共同操作的代码，比如：ticket就是共享数据

      ​ 3.同步监视器：俗称锁，任何一个类的对象，都可以充当锁，要求多个线程用同一把锁

      补充：在实现Runnable接口创建多线程的方式中，我们可以考虑使用this充当同步监视器

      ​ 在继承Thread类创建多线程的方式中，慎用this充当同步监视器。我们可以考虑使用当前类来充当同步监 视器。

    • 方式二：同步方法的方式

      class MyThread1 implements Runnable{
    private  int ticket = 100;//票

    @Override
    public void run () {
            while (true) {

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

    }
	//同步方法的方式解决
    public synchronized void show(){//同步监视器为this
        if (ticket > 0) {
            System.out.println(Thread.currentThread().getName() + "卖票。票号：" + ticket);
            ticket--;
        }
    }
}

      使用线程安全的方式解决单例模式中的懒汉式：

      class Bank{

    private Bank(){ }

    private static Bank instance = null;

    public static Bank getInstance() {
        //方式一：这种方式效率比较差
//        synchronized (Bank.class) {
//            if (instance == null) {
//                instance = new Bank();
//            }
//            return instance;
//        }
        //方式二：当instance不为空时，直接取走就行，不必进行等待
        if(instance == null){
            synchronized (Bank.class) {
                if (instance == null) {
                    instance = new Bank();
                }
            }
        }
        return instance;
    }
}

    1. 同步的方式，解决了线程的安全问题，但是操作代码块的时候，只能有一个线程参与，其他线程等待。相当于是一个单线程的过程，效率低

      案例：

      class MyThread implements Runnable{
    private  int ticket = 100;//票
    Object obj = new Object();//锁

        @Override
        public void run () {
        synchronized (this){//此时的this代表的就是唯一的MyThread 对象  synchronized (obj) {	加上锁
            while (true) {
                if (ticket > 0) {
                    System.out.println(Thread.currentThread().getName() + "卖票。票号：" + ticket);
                    ticket--;
                } else {
                    break;
                }

            }
        }
    }
}

      注意点：再继承Thread方式中，加锁时锁对象不能使用this,因为此时的 this 指代 t1,t2,t3三个对象

      synchronized(windows2.class){}//用类来指代对象

      方式三：使用Lock锁 -->JDK5.0新增

      1. 实例化ReentrantLock (locks接口的实现类)
      2. 进行上锁：调用锁定方法：lock()
      3. 调用解锁方法：unlock()
      package com.exer.java1;

import java.util.concurrent.locks.ReentrantLock;

/**
 * 方式三：使用Lock锁 -->JDK5.0新增
 * @author Token
 * @create 2021-11-14 21:44
 */
class windows implements Runnable{
    private int tickte = 100; //车票
    //1.实例化ReentrantLock
    private ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        while (true){

            //2.进行上锁：调用锁定方法：lock()
            lock.lock();
            try{
                if(tickte > 0){

                    //为了让问题出现的更加明显，让线程休眠100毫秒
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    System.out.println(Thread.currentThread().getName()+"卖票，票号：" + tickte);
                    tickte--;
                }else {
                    break;
                }
            }finally {
                //3.调用解锁方法：unlock()
                lock.unlock();
            }
            }

    }
}

public class LockTest {
    public static void main(String[] args) {
        windows w = new windows();

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

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

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

}

面试题：synchronized 与 Lock的异同？

相同：二者都可以解决线程安全问题

不同：

  • synchronized机制在执行完相应的同步代码以后，自动的释放同步监视器

  • Lock需要手动的启动同步（lock()），同时结束同步也需要手动的实现（unlock()）

使用的优先顺序：

  • Lock —> 同步代码块（已经进入了方法体，分配了相应资源 ) —> 同步方法（在方法体之外)

练习：

银行有一个账户。 有两个储户分别向同一个账户存3000元，每次存1000，存3次。每次存完打 印账户余额。 问题：该程序是否有安全问题，如果有，如何解决？


//账户类
class Accout{
    private double balance;//银行账户，存储金额

    public Accout(double balance) {
        this.balance = balance;
    }

    /**
     * 添加synchronized关键字，使得线程变成安全的
     * @param amt 存取金额
     */
    public synchronized void deposit(double amt){
        if (amt >0){
            balance +=amt;

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

            System.out.println(Thread.currentThread().getName()+":存钱成功，余额："+ balance);
        }
    }

}


//储户
class Customer extends Thread{
    private Accout acc;

    public Customer(Accout acc) {
        this.acc = acc;
    }

    @Override
    public void run() {
        for (int i = 0; i < 3; i++) {
            acc.deposit(1000);
        }

    }
}


public class AccoutTest {
    public static void main(String[] args) {
        Accout a = new Accout(0);//两个储户

        Customer c1 = new Customer(a);
        Customer c2 = new Customer(a);

        c1.setName("甲");
        c2.setName("乙");

        c1.start();
        c2.start();
    }
}

线程的几个主要概念

在多线程编程时，你需要了解以下几个概念：

  • 线程同步
  • 线程间通信
  • 线程死锁
  • 线程控制：挂起、停止和恢复

多线程的使用

有效利用多线程的关键是理解程序是并发执行而不是串行执行的。例如：程序中有两个子系统需要并发执行，这时候就需要利用多线程编程。

通过对多线程的使用，可以编写出非常高效的程序。不过请注意，如果你创建太多的线程，程序执行的效率实际上是降低了，而不是提升了。

请记住，上下文的切换开销也很重要，如果你创建了太多的线程，CPU 花费在上下文的切换的时间将多于执行程序的时间！

魏皇子
关注
专栏目录
java 线程怎么写_如何使用Java编写多线程程序
weixin_35696012的博客
03-07 138
二、准备知识在分析这个例子之前，然我们先看看关于线程的几个概念，上锁，信号量，和java所提供的API。上锁对于大多数的程序而言，他们都需要线程之间相互的通讯来完成整个线程的生命周期，二实现线程之间同步的最简单的办法就是上锁。为了防止相互关联的两个线程之间错误地访问共享资源，线程需要在访问资源的时候上锁和解锁，对于锁而言，有读锁，写锁和读写锁等不同的同步策略。在java中，所有的对象都有锁；线程只...
java 线程实现_用JAVA实现多线程
weixin_27956639的博客
02-19 135
用 JAVA 实现多线程 马 　铭 (吉林师范学院) 摘 　要 　多线程是现代操作系统中出现的概念。Java 虚拟机支持同时执行多个线 程。本文阐述了多线程的概念以及怎样使用Java 语言的多线程特性。 关键词 　多线程 ; 优先级 ; 线程同步 Windows95 和 Windows NT 操作系统支持多任务调度和处理 , 由此提出了多任务空间。 程序员可控制应用程序中每一个片段的运行 , 从而...
Java面试题，即继承Thread重写run方法又实现了Runnable接口重写run方法，谁会执行？
qq_60479747的博客
08-17 487
原因：Thread匿名子类的构造器不需要target，当他没有重写run（）方法时，他会去找父类的run（）方法，他才会用到target变量，调用target.run（）传入的Runnable target形参才会起作用但是Thread子类重写了run（）方法，就不需要target变量了，传入Runnable target形参也就不起作用了，所以就会执行Thread匿名子类的构造器。//Java面试题，即继承Thread重写run方法又实现了Runnable接口重写run方法，谁会执行？...
java runnable执行完_等待一个Runnable完成，然后再运行另一个Runnable
weixin_42163404的博客
03-04 1241
我有一个带有主标签页活动的Android应用程序，并且在单个标签页内有多个活动。在我的主要活动的onCreate()中，我有一个可运行的内容，它创建了一个列表，而在各个活动中，我都使用了此列表。在各个活动的onCreate()中，我还具有在列表上运行的Runnable。但是，我需要这些Runnable仅在主选项卡活动的Runnable完成创建列表时才运行，否则我将得到一个空列表。我正在尝试找到一种...
Java多线程编程核心技术_完整版_java_
09-30
Java多线程编程是Java开发中的重要组成部分，它允许程序同时执行多个任务，极大地提高了程序的效率和响应性。在Java中，多线程主要通过继承Thread类或实现Runnable接口来实现。本教程《Java多线程编程核心技术》将...
汪文君JAVA多线程编程实战（完整不加密）
01-19
《汪文君JAVA多线程编程实战》是一本专注于Java多线程编程的实战教程，由知名讲师汪文君倾力打造。这本书旨在帮助Java开发者深入理解和熟练掌握多线程编程技术，提升软件开发的效率和质量。在Java平台中，多线程是...
Java多线程编程实战指南(核心篇)
07-17
Java多线程编程实战指南(核心篇) 高清pdf带目录 随着现代处理器的生产工艺从提升处理器主频频率转向多核化，即在一块芯片上集成多个处理器内核（Core），多核处理器（Multicore Processor）离我们越来越近了――如今...
JAVA多线程编程技术PDF
08-28
这份“JAVA多线程编程技术PDF”是学习和掌握这一领域的经典资料，涵盖了多线程的全部知识点。 首先，多线程的核心概念包括线程的创建与启动。在Java中，可以通过实现Runnable接口或继承Thread类来创建线程。创建后...
Java多线程编程
05-02
Java多线程编程是Java开发中的重要组成部分，它允许程序同时执行多个任务，极大地提高了程序的效率和响应性。在Java中，多线程主要通过`Thread`类和并发工具来实现，接下来我们将深入探讨这些关键知识点。 1. **...
java重新执行_（转载）java线程 - 线程唤醒后并被执行时，是在上次阻塞的代码行重新往下执行，而不是从头开始执行...
weixin_31486261的博客
02-21 614
今天重新把昨晚的线程同步面试题做一遍时，发现实际情况运行下来时，线程一直不同步。后来经过不断测试，发现自己的一个误区。之前一直以为，线程如果被唤醒后再次执行时，会从头开始运行这个线程，也就是重新运行Runnable中的run()方法；而实际情况是，被唤醒并且被执行的线程是从上次阻塞的位置从下开始运行，也就是从wait()方法后开始执行。所以判断是否进入某一线程的条件 是用while判断，而不是用I...
java runnable执行完_java – 如何停止Runnable计划在一定数量的执行后重复执行
weixin_29369363的博客
02-13 2438
情况我有一个Runnable。我有一个类，计划这个Runnable执行使用一个ScheduledExecutorService与scheduleWithFixedDelay。目标我想改变这个类来调度Runnable的固定延迟执行无限期，或者直到它已经运行了一定次数，这取决于传递给构造函数的一些参数。如果可能，我想使用相同的Runnable，因为它在概念上是相同的事情，应该是“运行”。可能的方法方法...
编写一个java程序实现多线程_1. 写出用Java编写多线程程序的两种常用方法
weixin_39761573的博客
02-25 926
展开全部1、继承Thread，然后生成对象2、用类A实现runable接口，然后用你实现runnable的类A，生成Thread对象 Thread(A对象)；API 上说62616964757a686964616fe78988e69d8331333361303666明如下：创建新执行线程有两种方法。一种方法是将类声明为 Thread 的子类。该子类应重写 Thread 类的run 方法。接下来可以...
Java 多进程编程
weixin_47230102的博客
05-23 1949
Java 多线程编程1. 进程是什么2. 进程和线程是啥关系?3. 进程和线程的区别 1. 进程是什么 进程(process) => 任务(task) ~ 双击 .exe 文件的时候, 操作系统就会读取这个可执行文件中的代码和数据, 放到内存中, 并且创建出一个进程来执行里面的代码 一个操作系统, 工作的时候里面本来就有很多的进程 这些进程各自在做各自的事情, 互相不干扰 进程的重要特点: 独立性 某个进程出现问题的时候, 只是当前进程崩溃了, 不会干扰到其他的进程 例如: 编译运行java程序
诺基亚的裁员风暴
codenav的博客
10-28 1041
今日面试题：Nacos 中的 Namespace 是什么？
JavaScript中this的指向和改变this指向的方法 - 2024最新版前端秋招面试短期突击面试题【100道】
everfoot的博客
10-29 636
了解this的工作原理是掌握JavaScript的关键之一，特别是在编写复杂的应用程序时。正确使用this可以避免许多常见的问题和错误。在实际开发中，合理选择不同的绑定方法，可以让你的代码更加灵活和易于维护。掌握这些this的知识点将帮助你在前端面试中脱颖而出！祝你顺利上岸！
大厂面试真题-MVCC有哪些不好
最新发布
个人专长：数据结构和算法、大数据、数据库、主流框架
10-30 540
MVCC（Multi-Version Concurrency Control，多版本并发控制）虽然具有提高数据库并发性能、避免脏读等优势，但也存在一些缺点。
美团嵌入式面试题及参考答案（无人机团队）
大模型大数据攻城狮的专栏
10-29 526
在项目开始时，需要明确项目的背景和目标。背景通常源于实际的业务需求、市场需求或技术发展的推动。例如，在一个智能健康监测项目中，背景可能是随着人们对健康的重视程度不断提高，市场对能够实时监测人体健康指标（如心率、血压、睡眠质量等）的设备需求增加。基于这个背景，项目的目标就是开发一款智能健康监测设备，该设备能够准确地采集人体的健康数据，并通过无线通信将数据传输到用户的手机或云端服务器，同时为用户提供直观的健康分析报告和建议。
Java多线程编程实战指南
"Java多线程编程深入详解" 在Java编程中，多线程是并发执行任务的关键技术，它使得程序能够同时处理多个任务，提高了系统资源的利用率和程序的响应速度。本书深入讲解了Java多线程编程的各个方面，旨在帮助读者理解...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值