关于Java多线程的那些事

保姆级教程:用Python+OpenCV搞定Orbbec Gemini深度与彩色流对齐(附完整代码) 本文提供了一份详细的Orbbec Gemini深度与彩色流对齐教程,涵盖从环境配置到完整代码实现的每一步。通过解析深度流对齐原理,对比不同对齐模式,并提供工业级应用中的问题排查方法,帮助开发者快速掌握Orbbec Gemini相机的使用技巧。文章还包含进阶应用如点云生成与三维重建的实战代码。 阅读详情

多线程

1. 关于多线程的理解

1.1 进程和线程

每个进程有多个线程

  • 进程是系统运行程序的基本单元
  • 每个进程的内部数据和状态是完全独立的
  • 每一个应用程序运行的时候会产生一个进程
  • 线程:就是一个进程中的执行单元。一个进程可以启动多个线程。cpu 调度和分配的最小单元。
  • 线程必须在某个进程内执行。

所以多线程就是:在一个进程中同时运行了多个线程,用来完成不同的工作,则称之为多线程。

  • 进程与线程的区别
    • 进程:有独立的内存空间,进程中的数据存放空间(堆空间和栈空间)是独立的,至少
      有一个线程。
    • 线程:堆空间是共享的,栈空间是独立的,线程消耗的资源比进程小的多。

1.2 并行和并发

  1. 并发(Concurrency):

    • 并发是指多个任务在相同的时间段内交替执行,每个任务可能只执行一小部分,然后切换到另一个任务。
    • 并发并不一定意味着多个任务同时在不同的处理器核心上执行。它可以在单个处理器上通过时间片轮转来实现,也可以在多个处理器核心上并行执行。
    • 通常,多线程程序是并发的,因为它们可以在单个处理器上通过线程切换实现并发执行。

    示例:多个线程在单个处理器上轮流执行,共享CPU时间。

  2. 并行(Parallelism):

    • 并行是指多个任务在相同的时间点上同时执行,每个任务都在不同的处理器核心上运行。
    • 并行通常需要多核处理器或多个计算资源,并且可以实现更高的性能,因为多个任务可以在不互相干扰的情况下并行执行。
    • 并行通常用于解决需要高性能的问题,如大规模数据处理或计算密集型任务。

    示例:多个线程在不同的处理器核心上同时执行,各自独立工作。

总结:

  • 并发是任务在时间上交替执行,可能在同一处理器核心上通过线程切换实现。
  • 并行是任务在同一时刻同时执行,通常需要多个处理器核心或多个计算资源来实现。
  • 并发可以提高系统的响应性和资源利用率,但并不一定提高吞吐量。
  • 并行通常用于提高性能,特别是在多核处理器上,可以实现更高的吞吐量

1.3 线程调度

每个程序至少自动拥有一个线程,称为主线程

  1. 分时调度
    所有线程轮流使用 CPU 的使用权,平均分配每个线程占用 CPU 的时间。

  2. 抢占式调度

    优先让优先级高的线程使用 CPU,如果线程的优先级相同,那么会随机选择一个(线程随机性), Java 使用的为抢占式调度。

2. 创建多线程的方式

创建线程有哪几种方式?

创建线程有三种方式,分别是继承Thread类、实现Runnable接口、实现Callable接口。

2.1 通过继承Thread类来创建并启动线程的步骤如下:
  1. 定义Thread类的子类,并重写该类的run()方法,该run()方法将作为线程执行体。

  2. 创建Thread子类的实例,即创建了线程对象。

  3. 调用线程对象的start()方法来启动该线程。

/**
 * 实现多线程的第一种方式
 *      第一种方式:编写一个类,直接继承java.lang.Thread,重写run方法
 */
public class ThreadDemo01 {
    public static void main(String[] args) {
        System.out.println("main start!");
        MyThread myThread = new MyThread();
        myThread.test();        // 不会启动线程
        // 只有调用s'tart
        myThread.start();
        for (int i = 0; i < 10; i++) {
            System.out.println("main线程");
        }
    }
}
// 自定义线程类
class MyThread extends Thread{
    @Override
    public void run(){
        Thread thread = Thread.currentThread();     // 获取当前线程
        thread.setName("自定义线程");    // 设置当前线程的名字
        String name = thread.getName();     // 获取当前线程的名字
        for (int i = 0; i < 10; i++) {
            System.out.println(name + i);
        }
    }
    public void test(){
        System.out.println("test");
    }
}
2.2 通过实现Runnable接口来创建并启动线程的步骤如下:
  1. 定义Runnable接口的实现类,并实现该接口的run()方法,该run()方法将作为线程执行体。
  2. 创建Runnable实现类的实例,并将其作为Thread的target来创建Thread对象,Thread对象为线程对象。
  3. 调用线程对象的start()方法来启动该线程。
/**
 * 实现多线程的第二种方式
 *      第二种方式:编写一个类,实现java.lang.Runnable接口
 */
public class ThreadDemo02 {
    public static void main(String[] args) {
        // 创建任务对象
        MyRunnable myRunnable = new MyRunnable();
        // 创建线程
        Thread tr = new Thread(myRunnable,"线程1");
        // 启动线程
        tr.start();
        System.out.println("主线程");

        // 除了上面使用的自定义类实现Runnable接口之外,还可以使用匿名内部类、lambda表达式来实现Runnable接口
        Runnable runnable1 = new Runnable() {
            @Override
            public void run() {
                System.out.println("使用匿名内部类实现Runnable接口。。");
            }
        };
        new Thread(runnable1).start();
        Runnable runnable2 = ()->{
            String name = Thread.currentThread().getName();
            System.out.println(name + ":使用匿名内部类实现Runnable接口。。");
        };
        new Thread(runnable2).start();
    }
}
// 自定义类实现 Runnable 接口
class MyRunnable implements Runnable{
    @Override
    public void run() {
        String name = Thread.currentThread().getName();
        System.out.println(name + "实现线程的第二种方式.");
    }
}
2.3 通过实现Callable接口来创建并启动线程的步骤如下:
  1. 创建Callable接口的实现类,并实现call()方法,该call()方法将作为线程执行体,且该call()方法有返回值。然后再创建Callable实现类的实例。
  2. 使用FutureTask类来包装Callable对象,该FutureTask对象封装了该Callable对象的call()方法的返回值。
  3. 使用FutureTask对象作为Thread对象的target创建并启动新线程。
  4. 调用FutureTask对象的get()方法来获得子线程执行结束后的返回值。
/**
 * 创建线程的第三种方式:
 *      实现Callable接口
 */
public class ThreadDemo03 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // 使用匿名内部类实现Callable接口
        Callable<Integer> callable = new Callable<>() {
            @Override
            public Integer call() throws Exception {
                int sum = 0;
                for (int i = 1; i < 10; i++) {
                    sum += i;
                }
                // 返回一个结果
                return sum;
            }
        };
        // 创建一个FutureTask 对象,来接受异步计算的结果
        FutureTask<Integer> futureTask = new FutureTask<>(callable);
        // 创建线程
        Thread thread = new Thread(futureTask);
        thread.start();
        // futureTask.get() 是在等待执行完毕获取结果,所以是在线程启动之后,才获取。
        System.out.println(futureTask.get());
    }
}

采用继承Thread类的方式、实现Runnable、Callable接口的方式创建多线程的优缺点:

  • 线程类只是实现了Runnable接口或Callable接口,还可以继承其他类。而如果是已经继承Thread 类,则不能再继承其它父类了。(所以实现接口可以避免 java 中的单继承的局限性)
  • 在实现Runnable、Callable接口的这种方式下,多个线程可以共享同一个target对象,所以非常适合多个相同的程序代码的线程去共享同一个资源的情况,实现解耦操作,较好地体现了面向对象的思想。
  • 线程池只能放入实现 Runnable 或 Callable 类线程,不能直接放入继承 Thread 的类
  • 劣势是,编程稍稍复杂,如果需要访问当前线程,则必须使用Thread.currentThread()方法。
  • 采用继承Thread类的方式创建多线程的优势是,编写简单,如果需要访问当前线程,则无须使用Thread.currentThread()方法,直接使用this即可获得当前线程。
    鉴于上面分析,因此一般推荐采用实现Runnable接口、Callable接口的方式来创建多线程。

3 run()和start()有什么区别?

run()方法被称为线程执行体,它的方法体代表了线程需要完成的任务,而start()方法用来启动线程。调用start()方法启动线程时,系统会把该run()方法当成线程执行体来处理。但如果直接调用线程对象的run()方法,则run()方法立即就会被执行,而且在run()方法返回之前其他线程无法并发执行。也就是说,如果直接调用线程对象的run()方法,系统把线程对象当成一个普通对象,而run()方法也是一个普通方法,而不是线程执行体。

4 线程是否可以重复启动,会有什么后果?

只能对处于新建状态的线程调用start()方法,否则将引发IllegalThreadStateException异常。

扩展阅读

当程序使用new关键字创建了一个线程之后,该线程就处于新建状态,此时它和其他的Java对象一样,仅仅由Java虚拟机为其分配内存,并初始化其成员变量的值。此时的线程对象没有表现出任何线程的动态特征,程序也不会执行线程的线程执行体。

当线程对象调用了start()方法之后,该线程处于就绪状态,Java虚拟机会为其创建方法调用栈和程序计数器,处于这个状态中的线程并没有开始运行,只是表示该线程可以运行了。至于该线程何时开始运行,取决于JVM里线程调度器的调度。

5. 说一说sleep()和wait()的区别

  1. sleep()是Thread类中的静态方法,而wait()是Object类中的成员方法;
  2. sleep()可以在任何地方使用,而wait()只能在同步方法或同步代码块中使用;
  3. sleep()不会释放锁,而wait()会释放锁,并需要通过notify() / notifyAll()重新获取锁。

6. 说一说notify()、notifyAll()的区别

  • notify()

    用于唤醒一个正在等待相应对象锁的线程,使其进入就绪队列,以便在当前线程释放锁后竞争锁,进而得到CPU的执行。

  • notifyAll()

    用于唤醒所有正在等待相应对象锁的线程,使它们进入就绪队列,以便在当前线程释放锁后竞争锁,进而得到CPU的执行。

7. 如何实现子线程先执行,主线程再执行?

启动子线程后,立即调用该线程的join()方法,则主线程必须等待子线程执行完成后再执行。

扩展阅读

Thread类提供了让一个线程等待另一个线程完成的方法——join()方法。当在某个程序执行流中调用其他线程的join()方法时,调用线程将被阻塞,直到被join()方法加入的join线程执行完为止。

join()方法通常由使用线程的程序调用,以将大问题划分成许多小问题,每个小问题分配一个线程。当所有的小问题都得到处理后,再调用主线程来进一步操作。

8. Thread 类的方法

8.1 构造方法

Thread中常用的构造方法有:

  • public Thread() :分配一个新的线程对象。
  • public Thread(String name) :分配一个指定名字的新的线程对象。
  • public Thread(Runnable target) :分配一个带有指定目标新的线程对象。
  • public Thread(Runnable target,String name) :分配一个带有指定目标新的线程对象并指定名字。

8.2 Thread 类的常用方法

  1. public static Thread currentThread() :返回对当前正在执行的线程对象的引用。

    Thread.currentThread(); // 执行这句代码的线程
    
  2. public void run(): 表示线程的任务。

    • 所有Thread的子类应该覆盖(重写)此方法
  3. public synchronized void start(): 线程开始执行;

    • 多次调用同一个线程的此方法是不合法的。
  4. public static native void sleep(long millis):使当前正在执行的线程以指定的毫秒数暂停(暂时停止执行),具体取决于系统定时器和调度程序的精度和准确性。 线程不会丢失任何CPU的所有权。

    //线程休眠5S
    Thread.sleep(5000);	
    
  5. public static void sleep(long millis, int nanos) :使当前正在执行的线程以指定的毫秒数加上指定的纳秒数暂停(暂时停止执行)

  6. public final String getName():返回此线程的名称

    Thread.currentThread().getName();//获取当前线程名称
    
  7. public final synchronized void setName(String name):将此线程的名称更改为等于参数name

  8. public final int getPriority():返回此线程的优先级

  9. public final void setPriority(int newPriority):更改此线程的优先级,1~10之间

  10. public final native boolean isAlive():测试这个线程是否活着。 如果一个线程已经启动并且尚未死亡,那么线程是活着的

public static void main(String[] args) {
   Runnable runnable = new Runnable() {
        @Override
        public void run() {
            for (int i = 0; i < 3; i++) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        }
    };
    Thread thread = new Thread(runnable);
    // isAlive():测试这个线程是否活着
    System.out.println(thread.isAlive());       // false
    thread.start();
    // 线程启动后尚未结束时返回 true
    System.out.println(thread.isAlive());       // true
}
  1. public final void join():等待线程死亡,等同于join(0)
  2. public final synchronized void join(long millis):等待这个线程死亡的时间最多为millis毫秒。 0的超时意味着永远等待
    • join可以理解为当我们调用某个线程的这个方法时,这个方法会挂起调用线程,直到被调用线程结束执行,调用线程才会继续执行。(让父线程等待子线程结束之后才能继续运行)
 public static void main(String[] args){
     Thread th= new Thread(runnable);
     th.start();
     try {
         // 在main执行, main线程等待 th 执行完毕后再执行
         th.join();
         // main线程等待 th 执行 1s 后再执行
//            th.join(1000);
     } catch (InterruptedException e) {
         throw new RuntimeException(e);
     }
     System.out.println("main end");
 }
  1. public void interrupt():中断这个线程,线程的中断状态标记为 true

  2. public static boolean interrupted():测试当前线程是否中断。 该方法可以清除线程的中断状态(设置中断状态为False) 。 换句话说,如果这个方法被连续调用两次,那么第二个调用将返回false(除非当前线程再次中断,在第一个调用已经清除其中断状态之后,在第二个调用之前已经检查过)。

  3. public boolean isInterrupted():测试这个线程是否被中断。 线程的中断状态不受此方法的影响。不清除中断状态。

public static void main(String[] args) {
    Runnable runnable = new Runnable() {
        @Override
        public void run() {
            Thread thread = Thread.currentThread();
            for (int i = 0; i < 10; i++) {
                if (i % 3 == 0) {
                    // 中断线程, 标记线程中断状态
                    thread.interrupt();
                }
                // 测试当前线程是否中断
                System.out.println(Thread.interrupted());//true false false true false false true false false true
            }

            int count = 0;
            while (!thread.isInterrupted()) {
                if (count == 5) {
                    // 当count == 5 时,线程就会被中断
                    thread.interrupt(); // 我想停
                }
                System.out.println("执行" + count ++);    // 执行0 执行1 执行2 执行3 执行4 执行5
            }
        }
    };
    Thread thread = new Thread(runnable);
    thread.start();
}
    • public static native void yield():导致当前执行线程处于让步状态。如果有其他可运行线程具有至少与此线程同样高的优先级,那么这些线程接下来会被调度。并不一定会让出去。
  1. public State getState():返回此线程的状态,返回值是Thread的一个内部类,枚举类State。线程状态可以是:

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

9. 线程的状态

线程状态具体含义
NEW一个尚未启动的线程的状态。也称之为初始状态、开始状态。线程刚被创建,但是并未启动。还没调用start方法。MyThread t = new MyThread()只有线程对象,没有线程特征。
RUNNABLE当我们调用线程对象的start()方法,那么此时线程对象进入了RUNNABLE状态。那么此时才是真正的在JVM进程中创建了一个线程,线程一经启动并不是立即得到执行,线程的运行与否要听令与CPU的调度,那么我们把这个中间状态称之为可执行状态(RUNNABLE)也就是说它具备执行的资格,但是并没有真正的执行起来而是在等待CPU的度。
BLOCKED当一个线程试图获取一个对象锁,而该对象锁被其他的线程持有,则该线程进入Blocked状态;当该线程持有锁时,该线程将变成Runnable状态。
WAITING一个正在等待的线程的状态。也称之为等待状态。造成线程等待的原因有两种,分别是调用Object.wait()、join()方法。处于等待状态的线程,正在等待其他线程去执行一个特定的操作。例如:因为wait()而等待的线程正在等待另一个线程去调用notify()或notifyAll();一个因为join()而等待的线程正在等待另一个线程结束。
TIMED_WAITING一个在限定时间内等待的线程的状态。也称之为限时等待状态。造成线程限时等待状态的原因有三种,分别是:Thread.sleep(long),Object.wait(long)、join(long)。
TERMINATED一个完全运行完成的线程的状态。也称之为终止状态、结束状态

当线程被创建并启动以后,它既不是一启动就进入了执行状态,也不是一直处于执行状态。在线程的生命周期中,有六种状态。在API中 java.lang.Thread.State 这个枚举中给出了六种线程状态。

线程从 Runnable (可运行)状态与非运行状态之间的转换问题:
在这里插入图片描述
多线程安全问题
(重点)关于多线程并发环境下,数据的安全问题
线程安全问题的出现主要是因为多线程并发访问共享资源时可能导致的竞态条件(Race Condition)和并发访问冲突。
具体内容点击这里:Java线程安全——关于多线程并发环境下,数据的安全问题

100天精通Python(爬虫篇)——第114天:爬虫基础模块之requests基础入门 一、request模块大总结 1. 下载安装 2. 常用属性或方法 3. response.text和response.content的区别: 4. 发送带headers参数请求 5. 发送带参数请求 6. 在headers参数中携带cookie 7. 超时参数timeout的使用 8. proxies代理参数的使用 9. 发送post请求............... 阅读详情

相关推荐

单细胞分析实战:用R语言绘制带连线的堆叠柱状图(附完整代码)

本文详细介绍了如何使用R语言绘制带连线的堆叠柱状图进行单细胞转录组数据分析,特别适用于展示细胞比例变化趋势。通过完整代码示例和实战技巧,帮助研究者优化多组别比较的可视化效果,提升科研图表质量。

yhn4567890的博客 390

Java多线程的那些事

说明 Java的特点有很多,像简单、易学、面向对象语言、健壮性、高性能 、分布式和多线程等,现在我们就来讲讲其中的一个特性----多线程 1、在说线程之前我们先来看看和线程息息相关的—进程 进程是程序的一次执行过程,是系统运行程序的基本单位,因此进程是动态的。 系统运行一个程序即是一个进程从创建,运行到消亡的过程。 在Java中,当我们启动main函数时其实就是启动JVM的进程,而main函数所...

Fight Bravely的博客 235

【STM32-DSP库的使用】基于Keil5 + STM32CubeMX + CMSIS-DSP 手动添加、库添加方式

CMSIS-DSP库在工程中应用遇到的所有问题进行归纳终结

洋洋的博客 1万+

【Java那些事】java多线程编程

在多线程编程下,对处理并发时,可能产生重复工作的线程, 首先,从基础的说起 第一步如何创建一个线程、运行一个线程 Tread thread = new Thread(); thread.start();第二步,在线程里实现功能 这里大部分部分内容参考了http://ifeve.com/creating-and-starting-java-threads/ 由于,线程启动之后会自动运行ru

killer1989的博客 517

3D视觉引导技术在机器人焊接中的应用

通过对比传统的2D视觉和3D视觉技术在焊接领域的应用差异,探讨了3D视觉引导技术在提高焊接精度、适应不规则工件形状和增强自适应能力方面的优势。本文对3D视觉引导技术在机器人焊接中的应用进行了深入探讨,总结了其在提高焊接精度、适应不规则工件形状和增强自适应能力方面的优势,并通过应用案例展示了其在焊接路径规划、焊缝检测和焊接质量控制等方面的重要作用。1. 提高焊接精度:3D视觉引导技术能够精确测量焊接工件的三维形状和位置,为机器人提供精准的焊接路径规划和跟踪,从而提高焊接精度。三、3D视觉引导技术概述。

2302_79273122的博客 1836

ESP32-CAM搭建Arduino及简单使用

配置环境 方法一 文件 → 首选项 http://wechat.doit.am/package_esp8266com_index.json https://dl.espressif.com/dl/package_esp32_index.json 工具 → 开发板 → 开发板管理器 等待安装 方法二 https://github.com/espressif/arduino-esp32 Arduino安装目录下,找到hardware文件夹 建立文件夹espressif,然后在里面再建立一个esp32文件夹

Ying的博客 2万+

java多线程那些事之一

1.  Callable 接口        获取线程执行状态(get、get(long timeout)),取消线程(cancel(boolean  mayinterruptifrunning)),isCancel,isDone等。 1.  实现callable 接口, 2.  创建线程池,submit thread 如下所示: Future processF

Just Do It! 3176

【Bug已解决】Claude Team Plan 购买席位报错 Payment failed 解决方案

方案适用场景推荐指数检查账单历史状态排查的第一步⭐⭐⭐⭐⭐更换支付方式类型快速尝试是否能绕开问题⭐⭐⭐联系官方支持团队最终解决问题的正规渠道⭐⭐⭐⭐⭐临时过渡方案紧急用人需求的应急处理⭐⭐⭐关注官方修复进度确认属于系统性缺陷的场景⭐⭐⭐⭐Claude Team Plan 增购席位报的问题,社区反馈和实际排查表明很大概率属于平台计费系统在处理按比例分摊费用这类复杂计算链路时的系统性缺陷,而不是用户自身的支付信息填写有误。先排除自身账单历史是否存在异常。

一键难忘的博客 4187

java多线程及同步那些事

一.多线程的实现方式 1.继承Thread类重写run()方法 2.实现Runnable接口,new Thread(Runnable接口) 3.实现Callable接口通过FutureTask包装器来创建Thread线程 4.使用ExecutorService、Callable、Future实现有返回结果的线程ExecutorService、Callable、Future三个接口实际上都是

pangrui201的专栏 381

基于STM32L4XX、HAL库的RTL8211FSI-CG以太网收发器(PHY)驱动程序设计

一、简介:RTL8211FSI-CG是Realtek公司生产的一款高性能、低功耗的单端口10/100M以太网收发器(PHY)。它通过RMII(Reduced Media Independent Interface)或MII接口与MAC控制器连接。

zhusl6688的博客 536

零基础做完YOLOv8船只检测系统:HRSC2016数据集 + 完整UI,稳过答辩

亲爱的同学,通过这篇教程,你已经掌握了“基于YOLOv8的HRSC2016微小船只检测系统”从数据集处理、模型训练到Tkinter界面开发的全流程。这个课题既贴合“海事智能化”的产业战略,又涵盖了“目标检测、深度学习、界面开发”等多个毕设评分点,非常适合作为计算机或海事工程专业的毕业设计。在实践中,你可能会遇到“海面背景复杂导致船只漏检”“微小船只识别精度不足”“UI与模型推理同步卡顿”等挑战——别担心,这些都是技术成长的必经之路。

FJN110的博客 110

Java_多线程那点事

ConcurrentHashMap 并发度高,整个 ConcurrentHashMap 对应多把锁,只要线程访问的是不同锁,那么不会冲突。**保证可见性:**用volatile修饰的共享变量,能够防止编译器等jit优化发生,让一个线程对共享变量的修改对另一个线程可见。会导致ABA问题(所谓的ABA问题就是A线程修改B中的原本值修改为新值,另一个A线程又将新值修改为原本值,B无法得知这一变化)ThreadLocal可以实现【资源对象】的线程隔离,让每个线程各用各的【资源对象】,避免争用引发的线程安全问题。

Soil77的博客 171

【产品经理修炼之道】- 基金产品-“TA系统 ”

TA:Transfer Agent 缩写,通常称成“登记过户”。开放式基金登记过户(TA)系统是基金的登记过户系统。其功能涵盖了基金交易业务的各个环节,包括账户业务处理,如投资者开户、修改账户资料、挂失/解挂等;日常交易业务处理,如认购、申购(一般申购和定期定额)、赎回(一般赎回、指定赎回、预约赎回等)、转托管、基金转换等;特殊业务处理,如非交易过户、账户冻结/解冻等;分红业务处理,如现金分红和红利再投资。

xiaoli8748的专栏 1679

java多线程 简书_java多线程的那些事

引言在平时的工作中,经常能碰到程序需要对大量的数据进行相同的操作,如果只是传统的单线运行,无疑会碰到执行时间过长。尤其是在处理一些即时性要求较高的数据的时候,处理太慢无疑就是事故级别的存在了。因此,这个时候,我们就可以考虑多线程。为什么要使用多线程没有什么问题是多线程解决不了的,如果有,就再起一个线程。线程作为计算机调度资源的基本单位,使用多线程,可以充分利用CPU资源,避免由于某个任务执行时间过...

weixin_42234804的博客 118

计算机控制技术及应用

《计算机控制技术及应用》通过总结作者的科研成果和吸收国内外的先进理论、方法和技术,以计算机控制系统的网络化、开放化、智能化和集成化发展趋势为主线索,主要介绍计算机控制系统的基本概念和计算机控制系统的典型形式,计算机控制系统的数学描述与基本分析方法,以及数字PID控制器、最少拍控制系统、达林算法、状态变量设计法等设计方法及其各种改进算法。重点突出计算机控制系统输入输出通道接口的设计方法和典型控制系统的设计案例与实现方法等。

WINCC7.3破解文件

WINCC7.3硬件够破解文件,有需要的下载!WINCC7.3硬件够破解文件,有需要的下载!

Java多线程之volatile的那些事

本篇笔记主要梳理总结一下volatite的学习、应用心得,共享出来供大家一块学习、进步。内容叙述比较随便,请大家见谅! 一场由并发"引发"的学案        有个对陈凯歌电影《无极》的调侃,说是一个馒头引发了一场"血案"。看似调侃,但却真实地反映了人类需求和供给之间矛盾严重不平衡时所埋下的灾难,尤其在幼小的心灵中。馒头只有一个,有很多人需要,而占有它的人(不管当下需要不需要)又不让给...

xiaonanforever_0的博客 284

复分析 阿尔福斯(Ahlfors) 第三版答案 英文

答案分为十章,有部分习题没有答案,全英文复分析阿尔福斯(Ahlfors) 第三版答案

Java多线程那些事之ConcurrentHashMap

1. HashTable,SynchronizedHashmap,ConcurrentHashmap JDK 1.5之前在多线程环境下,map的实现只有hashtable和synchronized  hashmap,因为hashmap本身不是线程安全的。 ConcurrentHashmap不仅仅是线程安全的,而且在性能上优于hashtable和synchronized hashmap

Just Do It! 737

lwip-2.0.3

lwip是瑞典计算机科学院(SICS)的Adam Dunkels 开发的一个小型开源的TCP/IP协议栈。实现的重点是在保持TCP协议主要功能的基础上减少对RAM 的占用。

java多线程那些事

多线程那些事 0.多线程实现两种方式:  .new Thread(    public void run(){   //anything u want do;    }  ).start();  .new Thread(   new Runnable(){    public void run(){     //look up;    }   }  ).start();

u010869338的专栏 733

Java多线程那点事

Java多线程入门 本文主要介绍java中多线程的使用方法、线程同步、线程数据传递、线程状态及相应的一些线程函数用法、概述等。 进程和线程的区别: 进程:每个进程都有独立的代码和数据空间(进程上下文),进程间的切换会有较大的开销,一个进程包含1–n个线程。(进程是资源分配的最小单位,操作系统中运行的一个个软件就是一个个进程) 线程:同一进程中的线程共享代码和数据空间,每个线程有独立的运...

wmingstar 317

Java那些事之多线程

Java中的多线程经常被使用,而且功能还是比较强大的。下面来简单介绍一下。 本人经常使用的多线程方式是去实现Runnable的run方法,然后在外面用start方法进行调用。这样感觉思路更清晰一些。 好了,上代码,一看就明白了。 比如我要设计一个线程A. 代码如下: public class ThreadA implements Runnable{        /*     * (...

weixin_34396902的博客 85

Java 多线程那点事

一、首先讲解 Volatile 关键字,上Demo,大家思考下,"子线程结束"这句话能不能打印呢? public class VolatileTest { public static void main(String[] args) { MyVolatileRunnable myVolatileRunnable = new MyVolatileRunnable(); new Thread(myVolatileRunnable).start(); try {

weixin_39413778的博客 169

Java关于多线程你不知道的5件事

1. 同步方法或同步代码块? 您可能偶尔会思考是否要同步化这个方法调用,还是只同步化该方法的线程安全子集。在这些情况下,知道 Java 编译器何时将源代码转化为字节代码会很有用,它处理同步方法和同步代码块的方式完全不同。 当 JVM 执行一个同步方法时,执行中的线程识别该方法的 method_info 结构是否有 ACC_SYNCHRONIZED 标记设置,然后它自动获取对象的锁,调用

slamzwl的专栏 565

Java多线程编程那些事:volatile解惑

(本文最初由本人黄文海发表在InfoQ中文站上:http://www.infoq.com/cn) 1、 前言 volatile关键字可能是Java开发人员“熟悉而又陌生”的一个关键字。本文将从volatile关键字的作用、开销和典型应用场景以及Java虚拟机对volatile关键字的实现这几个方面为读者全面深入剖析volatile关键字。 volatile字面上有“挥发性的,不稳

vAgile的专栏 673

java多线程那些事之二Cyclincbarrier和countdownlatch

1. CyclicBarrier public class JavaCyclicBarrierExample { public static void main(String[] args) { //3 threads are part of the barrier, ServiceOne, ServiceTwo and this main thread calling th

Just Do It! 806

Java多线程--Thread类的那些事 1.

isDemon();上述创建一个线程去执行i循环,main线程执行n循环中,每次的执行顺序是不一样的,线程会抢占式执行,就是当前cpu在执行一个线程时,线程调度程序会调度另一个线程在这个cpu上执行,原本在cpu上执行的那个线程会暂停执行即进入阻塞,等待下一次的调度.不过在多个线程一起运行时他们的执行的先后顺序是不确定的,这是由操作系统内核的线程调度程序中的"调度器"进行调度,但种调度类似于一种"随机调度"抢占式执行,这样就使线程的执行顺序不确定,执行的时间也不好确定.如上述的代码运行结果。

weixin_74742634的博客 1157

java多线程那点事|提升java能力

java多线程那点事|提升java能力

lch_blog 182

Java——多线程锁的那些事

引入 Java提供了种类丰富的锁,每种锁因其特性的不同,在适当的场景下能够展现出非常高的效率。 下面先带大家来总体预览一下锁的分类图 1、乐观锁 VS 悲观锁 乐观锁与悲观锁是一种广义上的概念,体现了看待线程同步的不同角度。在Java和数据库中都有此概念对应的实际应用。 先说概念。对于同一个数据的并发操作,悲观锁认为自己在使用数据的时候一定有别的线程来修改数据,因此在获取数据的时候会先加锁,...

用代码征服天下 183
上一篇: 使用字节流实现文件的切割以及文件的合并、文件的复制(三种)
下一篇: 关于String、StringBuffer、StringBuilder
-今非昔比°
博客等级 码龄5年 213粉丝 83原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

-今非昔比°

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

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

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

打赏作者

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

抵扣说明:

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

余额充值