Java多线程

最新推荐文章于 2024-07-20 23:59:39 发布
最新推荐文章于 2024-07-20 23:59:39 发布
阅读量140 收藏
点赞数
分类专栏： 笔记 java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43696191/article/details/119741317
版权

文章目录

一、线程

1.1. 程序、进程和线程的概念

程序：为完成特定任，用某种语言编写的一组指令集合，指一段静态的代码；

进程：正在运行的一个程序，是资源分配的单位，是动态的；

线程：
  ①一个进程可以包含多个线程；
  ②是一个程序内部的一条执行路径；
  ③每个线程拥有独立的运行栈和程序计数器(pc)，线程切换的开销小；
  ④线程是调度和执行的单位；
  ⑤一个进程中的多个线程共享相同的内存单元/内存地址空间，可以访问相同的变量和对象
  ⑥若一个进程同一时间并行执行多个线程，就是支持多线程

一个Java应用程序，其实至少有三个线程：main()主线程，gc()垃圾回收线程，异常处理线程。当然如果发生异常，会影响主线程。

多线程程序的优点：

  1. 提高应用程序的响应。对图形化界面更有意义，可增强用户体验。
  2. 提高计算机系统CPU的利用率
  3. 改善程序结构。将既长又复杂的进程分为多个线程，独立运行，利于理解和修改

1.2. 并行和并发

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

1.3. 线程的分类

  1. 一种是守护线程，一种是用户线程。
  2. 它们在几乎每个方面都是相同的，唯一的区别是判断JVM何时离开。
  3. 守护线程是用来服务用户线程的，通过在start()方法前调用thread.setDaemon(true)可以把一个用户线程变成一个守护线程。
  4. Java垃圾回收就是一个典型的守护线程。
  5. 若JVM中都是守护线程，当前JVM将退出。

1.3. 线程的生命周期

新建： 当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态
就绪：处于新建状态的线程被start()后，将进入线程队列等待CPU时间片，此时它已具备了运行的条件，只是没分配到CPU资源
运行：当就绪的线程被调度并获得CPU资源时,便进入运行状态， run()方法定义了线程的操作和功能
阻塞：在某种特殊情况下，被人为挂起或执行输入输出操作时，让出 CPU 并临时中止自己的执行，进入阻塞状态
死亡：线程完成了它的全部工作或线程被提前强制性地中止或出现异常导致结束
在这里插入图片描述

二、多线程

2.1. 创建线程的方式一：继承Thread

2.1.1. 基本步骤

  1. 定义一个继承 java.lang.Thread类的子类；
  2. 重写run()方法；
  3. 创建子类的对象，即线程；
  4. 用对象调用start()，即启动线程

2.1.2. 实例

//问题：使用两个线程分别打印100以内的偶数和奇数。
public class ThreadTest {
    public static void main(String[] args) {
        //3.创建继承Thread类的子类对象,即线程
        OddNumber odd = new OddNumber();
        EvenNumber even = new EvenNumber();
        //给线程命名
        odd.setName("odd线程");
        even.setName("even线程");
        //4.启动线程
        odd.start();
        even.start();
    }
}

/**
 * 打印100以内的奇数
 */
//1.定义继承java.lang.Thread类的子类
class OddNumber extends Thread {
    //2.重写run()方法
    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {
            if (i % 2 != 0){
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    }
}

/**
 * 打印100以内的偶数
 */
//1.定义继承java.lang.Thread类的子类
class EvenNumber extends Thread {
    //2.重写run()方法
    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {
            if (i % 2 == 0){
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    }
}

2.2. 创建线程的方式二：实现Runnable

2.2.1. 基本步骤：

  1. 定义一个实现 java.lang.Runnable类的实现类；
  2. 实现run()方法；
  3. 创建实现类的对象；
  4. 将实现类的对象作为参数传到Thread(Runnable target)构造器中，创建Thread类的对象thread，即创建线程
  5. 用Thread类的对象调用start()，即启动线程；thread.start()

2.2.2. 实例

//问题：使用两个线程分别打印100以内的偶数和奇数。
public class ThreadTest {
    public static void main(String[] args) {
        //3.创建实现Runnable类的实现类对象
        OddNumber odd = new OddNumber();
        EvenNumber even = new EvenNumber();
        //4.将实现Runnable类的实现类对象作为参数传给Thread(Runnable target)构造器,创建线程
        Thread t1 = new Thread(odd);
        Thread t2 = new Thread(even);
        //给线程命名
        t1.setName("odd线程");
        t2.setName("even线程");
        //5.启动线程
        t1.start();
        t2.start();
    }
}

/**
 * 打印100以内的奇数
 */
//1.定义实现java.lang.Runnable接口的实现类
class OddNumber implements Runnable {
    //2.实现run()方法
    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {
            if (i % 2 != 0){
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    }
}

/**
 * 打印100以内的偶数
 */
//1.定义继承java.lang.Runnable类的子类
class EvenNumber implements Runnable {
    //2.实现run()方法
    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {
            if (i % 2 == 0){
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    }
}

2.3. 创建线程的方式三：实现Callable

2.3.1. 基本步骤：

  1. 定义一个实现 java.lang.Callable类的实现类；
  2. 实现call()方法；
  3. 创建实现类的对象；
  4. 将实现类的对象作为参数传到FutureTask(Callable target)构造器中，创建FutureTask类的对象futureTask，即创建线程
  5. 用FutureTask类的对象调用start()，即启动线程；futureTask.start()
  6. 获取实现类中call方法的返回值；Object callValue = futureTask.get()

2.3.2. 实例

//问题：使用两个线程分别打印100以内的偶数和奇数。
public class ThreadTest {
    public static void main(String[] args) {
        //3.创建实现Callable类的实现类对象
        OddNumber odd = new OddNumber();
        EvenNumber even = new EvenNumber();
        //4.将实现Callable类的实现类对象作为参数传给FutureTask(Callable target)构造器,创建FutureTask对象
        FutureTask<Integer> oddTask = new FutureTask<>(odd);
        FutureTask<Integer> evenTask = new FutureTask<>(even);

        //5.将FutureTask对象作为参数传给Thread(),创建线程
        Thread t1 = new Thread(oddTask);
        Thread t2 = new Thread(evenTask);
        //给线程命名
        t1.setName("odd线程");
        t2.setName("even线程");
        //6.启动线程
        t1.start();
        t2.start();
        try {
            //7.获取返回值,即100以内奇数和与100以内偶数和
            Integer oddSum = oddTask.get();
            Integer evenSum = evenTask.get();
            System.out.println("奇数总和 = " + oddSum);
            System.out.println("偶数总和 = " + evenSum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

/**
 * 打印100以内的奇数,并计算其和
 */
//1.定义实现java.util.concurrent.Callable接口的实现类
class OddNumber implements Callable<Integer> {
    //2.实现run()方法
    @Override
    public Integer call() {
        int sum = 0;
        for (int i = 0; i <= 100; i++) {
            if (i % 2 != 0){
                sum += i;
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
        return sum;
    }
}

/**
 * 打印100以内的偶数,并计算其和
 */
//1.定义继承java.util.concurrent.Callable类的子类
class EvenNumber implements Callable<Integer> {
    //2.实现run()方法
    @Override
    public Integer call() {
        int sum = 0;
        for (int i = 0; i <= 100; i++) {
            if (i % 2 == 0){
                sum += i;
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
        return sum;
    }
}

实现Runnable接口与实现Callable接口两种方式创建多线程的异同

所属包有无返回值是否可以抛异常是否支持泛型是否jdk5.0新增
Runnablejava.lang否否否是
Callablejava.util.concurrent是是是是

2.4. 创建线程的方式四：线程池

2.4.1. 使用线程池的优点

  1. 提高响应速度（减少了创建新线程的时间）
  2. 降低资源消耗（重复利用线程池中线程，不需要每次都创建）
  3. 便于线程管理

2.4.2. 实例

//问题：使用两个线程分别打印100以内的偶数和奇数。
public class ThreadTest {
    public static void main(String[] args) {

        //1.提供指定线程数的线程池
        ExecutorService service = Executors.newFixedThreadPool(10);
        ThreadPoolExecutor service1 = (ThreadPoolExecutor)service;
        //2.执行指定线程
        service1.execute(new OddNumber());
        Future<Integer> evenTask = service1.submit(new EvenNumber());
        try {
            //3.获取实现Callable接口的实现类的返回值
            Integer evenSum = evenTask.get();
            System.out.println("偶数总和 = " + evenSum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }finally{
            service1.shutdown();
        }
    }
}

/**
 * 打印100以内的奇数
 */
//1.定义实现java.lang.Runnable接口的实现类
class OddNumber implements Runnable {
    //2.实现run()方法
    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {
            if (i % 2 != 0){
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    }
}

/**
 * 打印100以内的偶数,并计算其和
 */
//1.定义继承java.util.concurrent.Callable类的子类
class EvenNumber implements Callable<Integer> {
    //2.实现run()方法
    @Override
    public Integer call() {
        int sum = 0;
        for (int i = 0; i <= 100; i++) {
            if (i % 2 == 0){
                sum += i;
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
        return sum;
    }
}

2.5. 线程中常用方法

start()                            //启动线程,调用当前线程的 run()方法
setName(String name)               //设置线程名称
getName()                          //获取当前线程名称
currentThread()                    //静态方法，返回执行当前代码线程
yield()                            //释放当前CPU的执行权
stop()                             //强制结束线程,已过时
suspend()                          //手动暂停当前线程,需要配合resume()使用
resume()                           //手动唤醒当前线程,需要配合suspend()使用
join()                           //在线程 a中调用线程 b的 join(),此时线程 a就进入阻塞状态，直到线程 b完全执行完以后，线程 a才结束阻塞状态。
sleep(long millitime)              //让当前线程 "睡眠 "指定的 millitime毫秒
isAlive()                          //判断当前线程是否存活
getPriority()                      //获取线程的优先级。
setPriority(int p)                 //设置线程的优先级。

线程的优先级

最高优先级:MAX_PRIORITY = 10;
最低优先级:MIN _PRIORITY = 1;
默认优先级:NORM_PRIORITY = 5

注意：高优先级的线程抢占cpu的执行权比低优先级线程抢占cpu的执行权的概率高，高优先级的线程高概率的情况下被执行。并不意味着只有当高优先级的线程执行完以后，低优先级的线程才执行。

三、线程安全

3.1. 实现线程安全的三种方式

3.1.1. 同步代码块

1、实现规则

synchronized(同步监视器){
	//需要被同步的代码
}

说明：
1.操作共享数据的代码，即为需要被同步的代码。不能包含代码多了，也不能包含代码少了。
2.共享数据：多个线程共同操作的变量。
3.同步监视器，俗称：锁。任何一个类的对象，都可以充当锁。要求：多个线程必须要共用同一把锁。

2、实例

//问题：加入有一个10000元的账户,丈夫和妻子两个人同时向这个账户分别取1000元,取两次
public class ThreadSynchronizd {
    //方式一：继承Thread类
    @Test
    public void thread() {
        //1.创建一个余额为10000的账户
        Account acc = new Account(10000);
        //2.创建两个线程,分别代表丈夫和妻子
        PersonThread husband = new PersonThread(acc);
        PersonThread wife = new PersonThread(acc);
        husband.setName("丈夫");
        wife.setName("妻子");
        //3.启动线程,开始取钱
        husband.start();
        wife.start();
    }

    //方式二：实现Runnable接口
    @Test
    public void runnable() {
        //创建两个线程,分别代表丈夫和妻子
        PersonRunnable runnable = new PersonRunnable();
        Thread husband = new Thread(runnable);
        Thread wife = new Thread(runnable);
        husband.setName("丈夫");
        wife.setName("妻子");
        //启动线程,开始取钱
        husband.start();
        wife.start();
    }


    //方式三：实现Callable接口
    @Test
    public void callable() {
        //创建实现Callable接口的实现类的对象    
        PersonCallable callable1 = new PersonCallable();
        PersonCallable callable2 = new PersonCallable();
        //创建实现FutureTask类的对象   
        FutureTask task1 = new FutureTask(callable1);
        FutureTask task2 = new FutureTask(callable2);
        
        //创建两个线程,分别代表丈夫和妻子
        Thread husband = new Thread(task1);
        Thread wife = new Thread(task2);
        husband.setName("丈夫");
        wife.setName("妻子");
        
        //启动线程,开始取钱
        husband.start();
        wife.start();
    }
}

/**
 * 余额为10000账户
 */
class Account {
    private double balance;

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

    public double getBalance() {
        return balance;
    }

    public void setBalance(double balance) {
        this.balance = balance;
    }
    //取钱的方法
    public void withdraw(double money) {
        balance -= money;
    }
}

/**
 * 取钱的人相当于两个线程
 */
class PersonThread extends Thread {
    private Account account;

    public PersonThread(Account account) {
        this.account = account;
    }
    @Override
    public void run() {
        int i = 1;
        while (i <= 2) {
            synchronized (Account.class) {
                account.withdraw(1000);
                System.out.println(Thread.currentThread().getName() + "第" + i + "次取钱成功,余额为: " + account.getBalance());
                i++;
            }
        }
    }
}

class PersonRunnable implements Runnable {
    private Account account = new Account(10000);
    @Override
    public void run() {
        int i = 1;
        while (i <= 2) {
            synchronized (this) {
                account.withdraw(1000);
                System.out.println(Thread.currentThread().getName() + "第" + i + "次取钱成功,余额为: " + account.getBalance());
                i++;
            }
        }
    }
}

class PersonCallable implements Callable {
    private static Account account = new Account(10000);
    @Override
    public Object call() {
        int i = 1;
        while (i <= 2) {
            synchronized (Account.class) {
                account.withdraw(1000);
                System.out.println(Thread.currentThread().getName() + "第" + i + "次取钱成功,余额为: " + account.getBalance());
                i++;
            }
        }
        return null;
    }
}

3.1.2. 同步方法

1、实现规则

如果操作共享数据的代码完整的声明在一个方法中，我们不妨将此方法声明同步的，在方法名前用synchronized修饰。

2、实例

//只需将3.1.1中实例中的同步代码块去除，然后再withdraw()方法前用synchronized修饰即可,如
public class ThreadSynchronizd {
    //方式一：继承Thread类
    @Test
    public void thread() {
    
        Account acc = new Account(10000);
        PersonThread husband = new PersonThread(acc);
        PersonThread wife = new PersonThread(acc);
        husband.setName("丈夫");
        wife.setName("妻子");

        husband.start();
        wife.start();
    }
}
/**
 * 余额为10000账户
 */
class Account {
    private double balance;

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

    public double getBalance() {
        return balance;
    }

    public void setBalance(double balance) {
        this.balance = balance;
    }

    //取钱的方法
    public synchronized void  withdraw(double money) {
        balance -= money;
    }
}

/**
 * 取钱的人相当于两个线程
 */
class PersonThread extends Thread {
    private Account account;

    public PersonThread(Account account) {
        this.account = account;
    }

    @Override
    public void run() {
        int i = 1;
        while (i <= 2) {
            account.withdraw(1000);
            System.out.println(Thread.currentThread().getName() + "第" + i + "次取钱成功,余额为: " + account.getBalance());
            i++;
        }
    }
}

3. 总结

  1. 同步方法仍然涉及到同步监视器，只是不需要我们显式的声明。
  2. 非静态的同步方法，同步监视器是：this； 静态的同步方法，同步监视器是：当前类本身

3.1.3. lock锁——jdk5.0新增

1. 基本步骤

  1. 实例化ReentrantLock：ReentrantLock lock = new ReentrantLock();
  2. 调用锁定方法lock()：lock.lock();
  3. 添加需要同步的代码
  4. 调用解锁方法unlock()：lock.unlock();

2. 实例

public class ThreadSynchronizd {
    @Test
    public void thread() {
        Account acc = new Account(10000);
        PersonThread husband = new PersonThread(acc);
        PersonThread wife = new PersonThread(acc);
        husband.setName("丈夫");
        wife.setName("妻子");
        husband.start();
        wife.start();
    }
}
/**
 * 余额为10000账户
 */
class Account {
    private double balance;
    public Account(double balance) {
        this.balance = balance;
    }

    public double getBalance() {
        return balance;
    }

    public void setBalance(double balance) {
        this.balance = balance;
    }
    //取钱的方法
    public void  withdraw(double money) {
        balance -= money;
    }
}

/**
 * 取钱的人相当于两个线程
 */
class PersonThread extends Thread {
    private Account account;
    //1.实例化ReentrantLock
    private ReentrantLock lock = new ReentrantLock();

    public PersonThread(Account account) {
        this.account = account;
    }
    @Override
    public void run() {
        int i = 1;
        while (i <= 2) {
            //2.调用锁定方法lock()
            lock.lock();
            account.withdraw(1000);
            System.out.println(Thread.currentThread().getName() + "第" + i + "次取钱成功,余额为: " + account.getBalance());
            i++;
            //3.调用解锁方法unlock()
            lock.unlock();
        }
    }
}

3. synchronized 与 Lock的异同？

相同：二者都可以解决线程安全问题
不同：①synchronized机制在执行完相应的同步代码以后，自动的释放同步监视器；
   ②Lock需要手动的启动同步（lock()），同时结束同步也需要手动的实现（unlock()）

4. 死锁问题

四、线程通信

1. 实例

//使用两个线程打印 1-100。线程1, 线程2 交替打印
public class PrintNumber {
    public static void main(String[] args) {
        Number number = new Number();
        Thread t1 = new Thread(number);
        Thread t2 = new Thread(number);
        t1.setName("t1");
        t2.setName("t2");
        t1.start();
        t2.start();
   }
}

class Number implements Runnable {
    int i = 0;
    @Override
    public void run() {
        while(true){
            synchronized (this) {
                notify();
                if (i <= 100) {
                    System.out.println(Thread.currentThread().getName() + ": " + i++);
                } else {
                    break;
                }
                try {
                    wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

2. 涉及到的方法

  1. wait():一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器。
  2. notify():一旦执行此方法，就会唤醒被wait的一个线程。如果有多个线程被wait，就唤醒优先级高的那个。
  3. notifyAll():一旦执行此方法，就会唤醒所有被wait的线程。

3. 说明

  1. wait()，notify()，notifyAll()三个方法必须使用在同步代码块或同步方法中。
  2. wait()，notify()，notifyAll()三个方法的调用者必须是同步代码块或同步方法中的同步监视器；否则，会出现IllegalMonitorStateException异常
  3. wait()，notify()，notifyAll()三个方法是定义在java.lang.Object类中。

4. sleep() 和 wait()的异同？

  1. 相同点：一旦执行方法，都可以使得当前的线程进入阻塞状态。
  2. 不同点： 1）两个方法声明的位置不同：Thread类中声明sleep() , Object类中声明wait()
         2）调用的要求不同：sleep()可以在任何需要的场景下调用。 wait()必须使用在同步代码块或同步方法中
         3）关于是否释放同步监视器：如果两个方法都使用在同步代码块或同步方法中，sleep()不会释放锁，wait()会释放锁。

5. 生产者—消费者模式
Eliaukの
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java如何进行传感器数据传输_工程师解决传输接口到传感器数据传输的几大方法...
weixin_31519139的博客
02-28 1594
传感器的数量在整个地球表面和人们生活周遭空间激增，提供世界各种数据讯息。这些价格亲民的传感器是物联网(IoT)发展和我们的社会正面临数字化革命，背后的驱动力。然而，连接和获取来自传感器的数据并不总是直线前进或那么容易，以下有5个技巧以协助缓解工程师与传输接口到传感器的第一次战争。技巧1―先从总线工具开始第一步，工程师应当采取首次介接到传感器时，是透过一个总线工具的方式以限制未知。一个总线工具连接一...
使用Java实现简单串口通信
AnOrdinaryLife的博客
03-14 1225
使用Java实现简单串口通信最近一门课要求编写一个上位机串口通信工具，我基于Java编写了一个带有图形界面的简单串口通信工具，下面详述一下过程，供大家参考 ^_^一：首先，你需要下载一个额外的支持Java串口通信操作的jar包，由于java.comm比较老了，而且不支持64位系统，这里推荐Rxtx这个jar包（32位/64位均支持）。官方下载地址：http://fizzed.com/oss/rxt...
java 串口调试 传感器指令发送与数据接收
夏沐的博客
10-17 8430
    本文主要讲述串口调试的Java工具类，并实现循环发送指令，接收数据！！     本文主要实现的功能是调用工具类中打开串口方法，连接传感器所在串口，向串口（传感器）发送指令，并接收串口（传感器）数据。 主函数-----main（）： public static void main(String[] args){ SerialTool st =SerialTool.getSeria...
Java通过socket和DTU,RTU连接工业传感器通信
duyabc的博客
10-13 2442
目录 总体架构图 工业名称解释 思路整理 结尾 现在做DTU传感器监测数据一块，给大家分享如何通过socket技术连接到DTU，并能和DTU下面的传感器通信的，分享一下自己的心得和体会。 总体架构图 先来看下整体网络结构图。 工业名称解释 传感器：能够采集数据机器，电脑端通过下发指令通过DTU发给传感器，传感器通过DTU返回相应的数据给电脑端，比如雨量计能实时反馈雨量，这很好理解。 RTU：远程传输单元，可以是一台plc（程序过程控制），通俗理解就是能够编程的还可以将数据
Java多线程实战-实现多线程文件下载，支持断点续传、日志记录等功能
热门推荐
qq_35716689的博客
03-10 15万+
本文将介绍如何通过Java来实现一个多线程下载器。作者：牵着猫散步的鼠鼠
Java多线程（超详细！）
一只小菜鸡
05-13 12万+
1、什么是进程？什么是线程？ 进程是:一个应用程序（1个进程是一个软件）。 线程是：一个进程中的执行场景/执行单元。 注意：一个进程可以启动多个线程。 eg.对于java程序来说，当在DOS命令窗口中输入： java HelloWorld 回车之后。 会先启动JVM，而JVM就是一个进程。 JVM再启动一个主线程调用main方法。 同时再启动一个垃圾回收线程负责看护，回收垃圾。 最起码，现在的java程序中至少有两个线程并发， 一个是垃圾回收线程，一个是执行main方法的主线程。 3、进程和线程是什么关系？
java多线程（超详细）
zdl66的博客
08-14 10万+
进程就是正在运行中的程序（进程是驻留在内存中的）是系统执行资源分配和调度的独立单位每一进程都有属于自己的存储空间和系统资源注意：进程A和进程B的内存独立不共享。
Java多线程详解及示例
07-20
Java多线程编程是提升程序性能和响应性的关键技术。理解多线程的概念，掌握线程的创建、同步、通信、死锁避免等核心知识点，以及合理使用线程池，对于编写高效、稳定的并发程序至关重要。通过实践，开发者可以更好地...
java 多线程
11-07
java 多线程 知识相关，主要是介绍 java 多线程相关的知识
Java多线程编程总结
01-31
要认识多线程就要从操作系统的原理说起。以前古老的DOS操作系统（V6.22）是单任务的，还没有线程的概念，系统在每次只能做一件事情。比如你在copy东西的时候不能rename文件名。为了提高系统的利用效率，采用批处理来...
java多线程
05-02
Java多线程是Java编程中的核心概念，它允许程序同时执行多个任务，提高了程序的效率和响应速度。在Java中，实现多线程有两种主要方式：通过实现`Runnable`接口和继承`Thread`类。 1. 实现Runnable接口 当一个类...
Java多线程读取大文件
12-22
【Java多线程读取大文件】是一种优化的文件处理策略，特别适用于处理大型文本文件。在传统的单线程I/O操作中，读取大文件可能导致内存溢出（OOM），尤其是在尝试一次性加载整个文件到内存时。为了避免这个问题，我们...
利用java给传感器编程_Android：传感器编程
weixin_29204205的博客
03-02 1212
本节教程主要讲解Android传感器编程的基础知识，包括加速度传感器(accelerometer)、陀螺仪(gyroscope)、环境光照传感器(light)、磁力传感器(magnetic field)、方向传感器(orientation)、压力传感器(pressure)、距离传感器(proximity)和温度传感器(temperature)。一、前言我很喜欢电脑，可是笔记本还是太大，笔记本电脑再...
在eclipse中导入本地的jar包配置Junit环境步骤（包含Junit中的方法一直标红的解决方法）
最新发布
weixin_70987470的博客
07-20 216
从本地导入Junit
Promise 详解（原理篇）
山重水复疑无路，柳暗花明又一村。
07-20 470
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。
Java内存模型
weixin_44267758的博客
07-19 549
此处的变量不是指java编程中的变量，它包括了实例字段，静态字段和构成数值对象的元素，但不包括局部变量和方法参数。JMM规定所有变量都存储在主内存中。每条线程有自己的工作内存，工作内存中保留了该线程使用到变量的主内存的副本。线程对变量的所有操作都必须在工作内存中进行，不能直接读写主内存的变量，不同的线程间也无法直接访问对方工作内存的变量，线程之间的变量值传递需要通过主内存来完成。
JVM-垃圾回收与内存分配
m0_50846237的博客
07-19 741
JVM-垃圾回收与内存分配
java算法day19
TOMOT77的博客
07-20 120
我第一时间想到的方法是遍历二叉树+哈希。哈希用来统计数字出现的次数。之后遍历map收集结果。利用了BST的性质，即BST的中序序列是有序序列。
Java多线程深度解析
"《Java多线程详解》- 汪文君" 本书是关于Java多线程编程的深度解析，作者汪文君分享了他在工作中和学习中的理解和实践经验。书中内容详细介绍了多线程的基本概念、Java对多线程的支持以及如何在实际编程中运用多...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值