多线程简介

最新推荐文章于 2022-10-28 17:59:58 发布
最新推荐文章于 2022-10-28 17:59:58 发布
阅读量4.6k 收藏 24
点赞数 4
分类专栏： Java基础 文章标签： intellij-idea java intellij idea
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Bug_marker/article/details/121603064
版权

一、概念

1、并发与并行

  • 并行：多个任务在同一个时刻点同时执行。效率高
  • 并发：多个任务在同一段时间内分时执行。效率低，宏观上同时执行，微观上分时执行。

2、进程与线程

  • 进程：内存中正在运行的应用程序，是系统进行资源分配和调度的基本单位。每一个进程有自己独立的运行空间，相互之间不影响。进程就是程序的一次执行过程，即是一个进程从加载到内存到从内存中释放消亡的过程。
  • 线程：进程内部的独立运行单元，是操作系统能够进行运算调度的最小单位，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。

 

  • 多线程： 在一个进程中，可以同时开启多个线程，让多个线程同时去执行某些任务（功能）。多线程的目的是提高程序的运行效率。
  • 主线程：任何一个应用程序的运行，都有一个独立的运行入口。而负责这个入口的线程称为程序运行的主线程。Java程序的主线程即main线程。

 3、线程的调度

1. Java 程序的进程里面至少包含两个线程，主进程也就是 main()方法线程，另外一个是垃圾回收机制线程。每当使用 java 命令执行一个类时，实际上都会启动一个 JVM，每一个 JVM 实际上就是在操作系统中启动了一个线程，java 本身具备了垃圾的收集机制，所以在 Java 运行时至少会启动两个线程。

2. 由于创建一个线程的开销比创建一个进程的开销小的多，那么我们在开发多任务运行的时候，通常考虑创建多线程，而不是创建多进程。

3. 因为一个进程中的多个线程是并发运行的，那么从微观角度看也是有先后顺序的，哪个线程执行完全取决于 CPU 的调度，程序员是干涉不了的。而这也就造成的多线程的随机性。

线程的调度方式分两类： 分时调度 ， 抢占式调度（时间片轮转）。

分时调度：多个任务平均分配执行时间。

抢占式调度：线程之间抢夺CUP的执行权，谁抢到谁执行（随机性）。

二、Thread 类

 java.lang.Thread: 表示线程，是程序中执行的线程。 Java虚拟机允许应用程序同时执行多个执行线程。

1、多线程的创建 

创建一个新的执行线程有两种方法。

  • 创建子类，继承Thread类
  • 实现Runnable接口
  • 第一种方式
  1. 声明Thread的子类，声明一个类继承Thread。
  2. 在子类中重写run()方法，即线程任务。
  3. 创建子类对象。
  4. 启动多线程。
  • 成员方法         
void run•() 线程任务方法，需要多线程执行的代码都写在此方法内。
void start•() 开启新的线程，java虚拟机调用此线程的run方法。  

声明 Thread 子类 

// 声明Thread子类
public class MyThread extends Thread {
    // 重写run()方法，线程任务
    @Override
    public void run() {
        for( int i = 1; i <= 20; i++ ) {
            System.out.println("旺财..." + i );
        }
    }
}

测试代码

public class Demo {
    public static void main(String[] args) {
        // 创建子类对象
        MyThread mt = new MyThread();
        // 启动线程任务
        // mt.run(); 直接调用run()方法无法开启新的线程
        mt.start(); // 开启新线程并调用run()方法
​
        for( int i = 1; i <= 20; i++ ) {
            System.out.println("小强...." + i );
        }
    }
}

调用run()方法 和 start()方法的区别

2、线程名

  • 多线程对象在创建出来之后，都有默认的线程名，命名规则: Thread-x , 从0开始，逐一增加。我们可以通过方法给线程命名，同样也可以获取线程的名字。
  • 构造方法给线程命名

Thread(String name) 分配新的 Thread 对象,并命名。

  • 成员方法给线程命名

void setName•(String name) 将此线程的名称更改为等于参数 name 。  

  • 获取线程名

String getName•() 返回此线程的名称。  

  • 获取线程对象

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

线程代码演示

public class ThreadName extends Thread {
    // 构造方法
    public ThreadName() {
    }
    public ThreadName(String name) {
        super(name);
    }
​
    // 重写run()方法，线程任务
    @Override
    public void run() {
        for( int i = 1; i <= 20; i++ ) {
            System.out.println(getName() + ".." + i );
        }
    }
}

 测试代码演示

public class Demo {
    public static void main(String[] args) {
        // 创建线程对象一
        ThreadName tn1 = new ThreadName("旺财");
        // 获取线程的名字
        System.out.println( tn1.getName() );
​
        // 创建线程对象二
        ThreadName tn2 = new ThreadName();
        // 设置线程名字
        tn2.setName("来福..");
        // 获取线程的名字
        System.out.println(tn2.getName());
​
        // 启动线程
        tn1.start();
        tn2.start();
​
        // 主线程
        for( int i = 1; i <= 20; i++ ) {
            System.out.println(Thread.currentThread().getName() + i );
        }
    }
}

3、线程优先级

  • 每个线程都有优先级，具有较高优先级的线程优先于优先级较低的线程执行。线程的优先级范围是从 1- 10，默认的优先级是5。

优先级成方法

  • int getPriority•() 返回此线程的优先级。  
  • void setPriority•(int newPriority) 更改此线程的优先级。  

 线程代码演示

public class ThreadPriority extends Thread {
    // 构造方法
    public ThreadPriority() {
    }
    public ThreadPriority(String name) {
        super(name);
    }
    // 线程任务
    @Override
    public void run() {
        for ( int i = 1; i <= 20; i++ ) {
            System.out.println( getName() + ".." + i );
        }
    }
}

 测试代码演示

public class Demo {
    public static void main(String[] args) {
        // 创建线程任务
        ThreadPriority tp1 = new ThreadPriority("tp1.");
        ThreadPriority tp2 = new ThreadPriority("tp2..");
        ThreadPriority tp3 = new ThreadPriority("tp3...");
        // 设置线程优先级  tp2为默认优先级
        tp1.setPriority(1);
        tp3.setPriority(10);
        // 获取优先级
        System.out.println( tp1.getPriority() );
        System.out.println( tp2.getPriority() );
        System.out.println( tp3.getPriority() );
        // 启动线程
        tp1.start();
        tp2.start();
        tp3.start();
    }
}

4、守护线程

API中有这样的描述，每个线程可能也可能不会被标记为守护程序，并且当且仅当创建线程是守护进程时才是守护线程。

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

  • 用户线程：也就是普通线程，刚创建出来的线程都属于用户线程。
  • 守护线程：顾名思义，守护线程是用来守护的，专门用于服务用户线程，当程序中没有正在运行的用户线程时，守护线程会自动结束。垃圾回收线程就是典型的守护线程。

守护线程方法

  • void setDaemon•(boolean on) 将此线程标记为 daemon线程或用户线程。  
  • boolean isDaemon•() 测试这个线程是否是守护线程。

 线程代码演示

public class ThreadDaemon extends Thread {
    // 线程任务
    @Override
    public void run() {
        for ( int i = 1; i <= 200; i++ ) {
            System.out.println( "守护线程.." + i );
        }
    }
}

 测试代码演示

public class Demo {
    public static void main(String[] args) {
        // 创建线程对象
        ThreadDaemon td = new ThreadDaemon();
        // 将线程设置为守护线程
        td.setDaemon(true);
        // 启动线程
        td.start();
​
        /*
            主线程循环
                此时主线程就是一个用户线程，主线程循环20次，
                而上面的守护线程循环200次，注意当主线程执行
                结束之后，守护线程的执行数据
          */
        for( int i = 1; i <=20;i++ ) {
            System.out.println("main.." + i );
        }
    }
}

5、线程休眠

休眠方法

  • static void sleep•(long millis) 使当前正在执行的线程停留（暂停执行）指定的毫秒数，这取决于系统定时器和调度程序的精度和准确性。  

代码演示

public class Demo {
    public static void main(String[] args) throws InterruptedException {
        // 使用线程休眠方法 制作一个闹钟
        for( int i = 1;i <= 10; i++ ) {
            Thread.sleep(1000);
            System.out.println("第" + i + "秒");
        }
        System.out.println("叮铃铃...");
    }
}

三、Runnable 接口

  • java.lang.Runnable: 线程任务接口，该接口应由任何类实现，其实例将由线程执行。 类必须定义一个无参数的方法，称为run 。

多线程的第二种方式

1. 声明Runnable接口的实现类

2. 实现类中重写run()方法

3. 创建实现类对象

4. 创建Thread线程对象，并将实现类对象传递给构造方法。

5. 启动线程

Runnable实现类

public class MyRunnable implements Runnable {
    // 线程任务
    @Override
    public void run() {
        for( int i = 1; i <= 20; i++ ) {
            System.out.println(Thread.currentThread().getName() + i);
        }
    }
}

测试代码演示

public class Demo {
    public static void main(String[] args) {
        // 创建线程任务对象
        MyRunnable mr = new MyRunnable();
        // 创建线程对象
        Thread thread1 = new Thread(mr);
        Thread thread2 = new Thread(mr);
        // 启动线程
        thread1.start();
        thread2.start();
    }
}

2、线程两种创建方式的区别

打破了Java的单继承性

  • Java具备单继承性，一个子类只能继承一个父类。
  • 多线程的第一种创建方式，需要继承Thread类。如果此时这个类已经继承了其他的父类，就无法继承Thread类。如果改为继承Thread类就改变了这个类的当前继承体系。
  • 多线程的第二种创建方式，不需要类采用继承的方式实现，在实现Runnable接口的同时不会影响到类原有的继承体系。

实现类解耦

  • 多线程的第一种创建方式，线程对象和线程任务是直接耦合在一起的。
  • 多线程的第二种创建方式，实现了线程对象和线程任务的解耦。线程对象专门用来对线程本身进行操作，线程任务单独抽取到Runnable接口中独立操作。当一个类实现了Runnable接口，就相当于有了线程任务，创建Thread对象拿到线程任务就可以执行，达到了线程任务和线程对象的分离及结合。

四、匿名线程

第一种方式实现匿名线程

public class Demo {
    public static void main(String[] args) {
        // 创建Thread匿名子类
        new Thread(){
            // 线程任务
            @Override
            public void run() {
                System.out.println("线程启动...");
            }
        }.start();
    }
}

第二种方式实现匿名线程

public class Demo {
    public static void main(String[] args) {
        // 创建Thread匿名子类 传递匿名Runnable对象
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("线程启动...");
            }
        }).start();
    }
}

练习：就近原则，离的近的调用方法

public class Demo {
    public static void main(String[] args) {
        // 运行哪段代码
        new Thread(new Runnable() {
            // 匿名Runnable对象
            @Override
            public void run() {
                System.out.println("Runnable匿名实现类..线程启动...");
            }
        }){
            // Thread匿名子类
            @Override
            public void run() {
                System.out.println("Thread匿名子类类..线程启动...");
            }
        }.start();
    }
}

5、线程安全

1、线程的安全分析

  • 有时候我们需要使用多线程操作共享的数据，在操作共享数据的过程中特别容易发生线程的安全问题。下面我们通过一个案例来看一下线程安全问题发生的原因。

案例

  • 使用多线程模拟火车站售票，每一条线程相当于一个售票的窗口。而所有窗口所售的票是共享的，也就是说当有一个窗口把某张票卖出去之后，其他的窗口也就不能在卖那张票。窗口可以有多个，但是每一张票是唯一的。

线程任务

public class Ticket implements Runnable {
    // 声明变量 模拟车票
    private int num = 100;
    // 线程任务就是售票
    @Override
    public void run() {
        // 死循环模拟窗口在一直售票
        while ( true ) {
            // 判断是否还有车票
            if( num > 0 ) {
                // 获取线程名字
                String name = Thread.currentThread().getName();
                System.out.println( name + "售票：" + num );
                // 线程休眠，模拟出票时间
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                // 票数迭代，减去售出的票
                num--;
            }
        }
    }
}

测试类

public class Demo {
    public static void main(String[] args) {
        // 创建线程任务对象
        Ticket ticket = new Ticket();
        // 创建线程对象 模拟售票窗口
        Thread t1 = new Thread(ticket,"窗口一");
        Thread t2 = new Thread(ticket,"窗口二");
        Thread t3 = new Thread(ticket,"窗口三");
        Thread t4 = new Thread(ticket,"窗口四");
        // 启动线程
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

运行结果

 原因分析

  • 通过程序的运行结果可以看到，有些票被多次卖出，而有些票没有被卖出而是被覆盖掉。发生问题的原因是多线程在执行售票任务的时候，操作了共享的成员变量num。可是在操作num的过程中，一个线程操作到其中一部分代码的时候，CPU切换到其他线程开始执行线程任务，这样就导致了num变量的值被修改的不一致。

类似于上述的这些问题，我们称为线程的安全问题。而造成多线程安全问题的原因：

  1. 有多条线程
  2. 多个线程在操作共享的数据
  3. 操作共享数据的语句不止一条，并且对共享数据有修改
  • 本质的原因是CPU在处理多个线程的时候，在操作共享数据的多条代码之间切换导致的，一条线程的线程任务还没有直接结束，就切换到了另外一条线程。

解决方案

  • 上述的问题分析我们知道，造成安全的原因的CPU的随机切换造成的，但是CPU是由操作系统控制的，我们无法直接干预CPU的切换，所以只能从线程本身入手。

解决方案：我们可以人为的控制，当有一条线程在执行操作共享数据的代码时，不让其他线程进入到操作共享数据的代码中。只有当某条线程将操作共享数据的代码执行结束，其他线程才可以继续执行操作共享语句的代码。这样就可以保证线程的安全。

上述的解决方案，称为线程的同步。实现线程同步的方式有3种：

  1. synchronized同步代码块
  2. 同步方法
  3. Lock锁机制

2、同步代码块

语法：

synchronized (任意唯一锁对象) {
    操作共享数据的代码;
}
public class Ticket implements Runnable {
    // 声明变量 模拟车票
    private int num = 100;
    // 声明锁对象
    private Object lock = new Object();
    // 线程任务就是售票
    @Override
    public void run() {
        // 死循环模拟窗口在一直售票
        while ( true ) {
            // 同步代码块
            synchronized ( lock ) {
                // 判断是否还有车票
                if (num > 0) {
                    // 获取线程名字
                    String name = Thread.currentThread().getName();
                    System.out.println(name + "售票：" + num);
                    // 线程休眠，模拟出票时间
                    try {
                        Thread.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    // 票数迭代，减去售出的票
                    num--;
                }
            }
        }
    }
}

3、同步方法

        当在run()方法中调用了其他方法时，那么被调用的方法也间接变为了线程任务。

同步方法，就是使用synchronized关键字修饰的方法，当某个方法中的代码全部是操作共享数据的代码时，我们可以直接将当前方法声明为同步方法。

语法

public synchronized void methodName( 形参 ) {
    操作共享数据的代码;        
}
public class Ticket implements Runnable {
    // 声明变量 模拟车票
    private int num = 100;
    // 线程任务就是售票
    @Override
    public void run() {
        // 死循环模拟窗口在一直售票
        while ( true ) {
            ticket();
        }
    }
    // 声明一个专门售票的方法
    public synchronized void ticket() {
        // 判断是否还有车票
        if (num > 0) {
            // 获取线程名字
            String name = Thread.currentThread().getName();
            System.out.println(name + "售票：" + num);
            // 线程休眠，模拟出票时间
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            // 票数迭代，减去售出的票
            num--;
        }
    }
}

注意事项

  1. 只有方法中的所有代码都是操作共享数据的代码时，才使用synchronized声明为同步方法，否则会降低执行效率。
  2. run()方法不能使用synchronized修饰，否则线程任务无法被多线程执行。

4、继承实现售票案例

继承的方式不利于数据的共享，所以需要考虑的如何实现数据的共享问题。

public class Ticket extends Thread {
    // 声明变量 模拟车票 需要静态，保证车票被共享
    private static int num = 100;
    // 声明锁对象 需要静态，保证锁唯一
    private static Object lock = new Object();
    // 构造方法给线程命名
    public Ticket(String name) {
        super(name);
    }
​
    // 线程任务就是售票
    @Override
    public void run() {
        // 死循环模拟窗口在一直售票
        while ( true ) {
            // 同步代码块
            synchronized ( lock ) {
                // 判断是否还有车票
                if (num > 0) {
                    System.out.println(Thread.currentThread().getName() + "售票：" + num);
                    // 模拟出票时间
                    try {
                        Thread.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    // 迭代车票
                    num--;
                }
            }
        }
    }
}

测试类

public class Demo {
    public static void main(String[] args) {
        // 创建线程对象 模拟窗口
        Ticket ticket1 = new Ticket("窗口一");
        Ticket ticket2 = new Ticket("窗口二");
        Ticket ticket3 = new Ticket("窗口三");
        Ticket ticket4 = new Ticket("窗口四");
        // 启动线程
        ticket1.start();
        ticket2.start();
        ticket3.start();
        ticket4.start();
    }
}

5、同步的细节

当程序中加了同步之后，依然存在线程的安全问题，那么原因有如下两个

  1. 锁不唯一
  2. 同步代码块没有加在所有操作共享数据的代码上

同步的好处和弊端:

  1. 使用同步会影响程序的执行效率。每次CPU运行到同步代码时，都需要去判断有没有线程在同步代码中，如果只能等待同步代码中的线程执行结束。
  2. 好处显而易见是可以保证数据的安全。

在前面学习的：

  • StringBuffer它是线程安全的。提供的方法中有同步。只要有同步效率肯定会降低。
  • StringBuilder它是线程不安全的。

在集合中学习的JDK1.2出现的所以有集合都是线程不安全，JDK1.2之前的都是线程安全的。

Vector，Hashtable。

如果开发时需要对集合进行线程的安全操作，这时需要使用Collections中的方法，把不安全的集合变成安全的集合。

六、单例懒汉式线程安全问题 

单例设计模式：程序在运行的过程中只允许产生一个对象。

单例设计模式的实现过程一共3步：

  1. 私有构造方法。
  2. 本类创建对象。
  3. 提供公开静态获取本类对象的方法。

代码的实现分为懒汉式和饿汉式两种。

饿汉式

public class Single { 
   // 私有构造方法
    private Single(){
        
    }
    // 本类创建对象
    private static final Single s = new Single();
    // 返回本类对象的方法
    public static Single getInstance() {
        return s;
    }
}

懒汉式

public class Single {
   // 私有构造方法
    private Single(){}
    // 本类创建对象
    private static Single s = null;
    // 返回本类对象的方法
    public static Single getInstance() {
        if ( s == null ) {
            s = new Single();
        }
        return s; // 返回对象
    }
}
  • 上述的两种方式中，饿汉式的对象创建过程只有一条语句，不会发生线程的安全问题。但是懒汉式的对象创建不止一条语句，如果有多线程操作时，就会发生线程的安全问题。下面我们通过代码来验证一下，线程任务就是获取单例的对象，查看对象是否唯一。

线程任务

public class SingleThread implements Runnable {
    // 线程任务就是获取单例对象
    @Override
    public void run() {
        // 获取单例对象
        Single instance = Single.getInstance();
        // 打印对象
        System.out.println(instance);
    }
}

测试代码

public class Demo {
    public static void main(String[] args) {
        // 创建线程任务对象
        SingleThread st = new SingleThread();
        // 创建线程对象
        Thread t1 = new Thread(st);
        Thread t2 = new Thread(st);
        Thread t3 = new Thread(st);
        Thread t4 = new Thread(st);
        // 启动线程
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

运行结果

  •  通过多线程获取单例对象时发现并没有实现对象唯一，原因很简单，就是创建对象的语句有多条，而我们没有实现线程的同步。

线程同步：两次判断，第一次判断提高效率，第二次用来保证线程安全

public class Single {
    // 声明锁对象
    private static Object lock = new Object();
   // 私有构造方法
    private Single(){}
    // 本类创建对象
    private static Single s = null;
    // 返回本类对象的方法
    public static Single getInstance() {
        /*
            外出的判断可以提高程序的运行效率，当有一条线程创建完对象之后
            其他线程就不会在进入到同步代码块中。
          */
        if( s == null ) {
            // 同步代码块
            synchronized (lock) {
                if (s == null) {
                    s = new Single();
                }
            }
        }
        // 返回对象
        return s;
    }
}

七、多线程的死锁问题 （避免）

  • 死锁：多个线程操作共享数据，但是要求线程获取锁的先后次序不同。但是都必须根据自己的次序获取所有的锁才能去执行这个任务。而在获取锁的过程中，不同的线程获取方式不同，导致锁会被其他的线程占有。一旦发生这个问题，就立刻发生死锁问题。

案例

  • 有2个线程，需要执行相同的任务，但是需要分别获取的A和B锁才能去执行，第一个线程获取锁的顺序是先A后B。第二个线程获取锁的顺序是先B后A。

线程任务演示

public class DieThread implements Runnable{
    // 声明AB两个锁对象
    private Object lock_A = new Object();
    private Object lock_B = new Object();
    // 声明变量 控制执行流程
    boolean flag = false;
    @Override
    public void run() {
        if( flag ) {
            while ( true ) {
                // 获取A锁的同步代码块
                synchronized (lock_A ) {
                    System.out.println("if..lock_A 锁...");
                    // 获取B锁的同步代码块
                    synchronized (lock_B) {
                        System.out.println("if..lock_B锁...");
                    }
                }
            }
        } else {
            while (true){
                // 获取B锁的同步代码
                synchronized (lock_B) {
                    System.out.println("else..lock_B锁...");
                    // 获取A锁的同步代码块
                    synchronized (lock_A) {
                        System.out.println("else..lock_A锁...");
                    }
                }
            }
        }
    }
}

测试演示

public class Demo {
    public static void main(String[] args) throws InterruptedException {
        // 创建线程任务对象
        DieThread dt = new DieThread();
        // 创建线程对象
        Thread a = new Thread(dt);
        Thread b = new Thread(dt);
        // 启动线程任务
        a.start();
        // 线程休眠
        Thread.sleep(1);
        // 修改flag的值，让线程可以进入if语句
        dt.flag = true;
        // 启动线程
        b.start();
    }
}

 

Bug_marker
关注
  • 4
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
多线程的优点意义
CrazyIdeas的博客
09-13 5668
进程和线程都是由操作系统所体现的程序运行的基本单元，系统利用该基本单元实现系统对应用的并发性。 在操作系统中可以有多个进程，一个进程中又可以有一个或多个线程。进程是在自己独立的内存空间中运行的，所以进程与进程之间是不共享内存的。线程是把进程给分割开，每个线程之间可以共享系统分配给这个进程的内存空间。线程之间不仅可以共享进程的内存，而且还拥有一个属于自己的内存空间，这段内存空间叫做线程栈。是在建立
多线程简介以及在JAVA项目中的应用
04-07
5. Java多线程简介 在Java中，可以使用Thread类或Runnable接口来创建线程。Thread类是所有线程的基类，可以直接创建Thread对象并重写run()方法。而Runnable接口则提供了另一种方式，将线程逻辑封装在实现Runnable的...
多线程（超详细讲解）
qq_45903282的博客
10-28 753
多线程（超详细讲解）
多线程概念
Withered Wood
04-13 192
目录1. 什么是线程呢？2. 什么是进程呢？3. 什么是多线程呢？4. 为什么要使用多线程呢？5. 怎么创建线程？1）继承 Thread 类2）实现 Runnable 接口3）实现 Callable 接口4）run() 和 start() 的区别6. 线程的6个状态有哪些？ 1. 什么是线程呢？ 线程是CPU能够进行运算调度的最小单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务，互相之间并不同步。 线程是独立调度和分派的基本单位。线程不拥有系统资源，同一
Java多线程的知识点
weixin_59796310的博客
05-28 4877
Java多线程的知识点
为什么要使用多线程?你只知道多线程可以提高性能?
weixin_47303191的博客
04-25 652
面试的时候你可以这么回答 避免阻塞.因为在单线程中,各个线程是顺序执行的,也就是说,如果某个线程阻塞了,后面的线程也会被阻塞掉. 避免cpu空传.在线程里,一个线程结束的标志不是将核心逻辑执行完了就可以了,例如你要请求一个数据库,不是你请求完成就可以了,这个线程还要等待数据返回,对于我们来说,等待返回是完成没有必要的,浪费cpu,为了解决这个问题,可以引入多线程,然其他线程在这个时间执行,这样cpu就不会闲着了. 提高效率.多线程能并发或并行执行,极大地提高了cpu利用效率,并行的话就是多个线程同一个时间
***JAVA多线程的应用场景和应用目的举例
weixin_33963189的博客
07-23 1647
多线程使用的主要目的在于：1、吞吐量：你做WEB，容器帮你做了多线程，但是他只能帮你做请求层面的。简单的说，可能就是一个请求一个线程。或多个请求一个线程。如果是单线程，那同时只能处理一个用户的请求。2、伸缩性：也就是说，你可以通过增加CPU核数来提升性能。如果是单线程，那程序执行到死也就利用了单核，肯定没办法通过增加CPU核数来提升性能。鉴于你是做WEB的，第1点可能你几乎不涉及。那这里我就讲第二...
java的线程：概念与原理
xiaoli的博客
10-24 156
** java的线程：概念与原理 ** 一、操作系统中线程和进程的概念 现在的操作系统是多任务操作系统。多线程是实现多任务的一种方式。 进程是指一个内存中运行的应用程序，每个进程都有自己独立的一块内存空间，一个进程中可以启动多个线程。比如在Windows系统中，一个运行的exe就是一个进程。 线程是指进程中的一个执行流程，一个进程中可以运行多个线程。比如java.exe进程中可以运行很多线程。线程总是属于某个进程，进程中的多个线程共享进程的内存。 “同时”执行是人的感觉，在线程之间实际上轮换执行。 二、Ja
多线程简介与使用方法
12-23
多线程介绍，以及如何在iOS 项目中使用多线程进行操作
stm32单片机多线程实例
12-03
多线程是实现复杂任务并发执行的关键技术，能够提高资源利用率，优化系统响应时间。在STM32上实现多线程，通常会借助实时操作系统（RTOS）如RT-Thread。 RT-Thread是一个轻量级、开源的实时操作系统，它为STM32等微...
javad多线程
12-25
比较详细的方法解读，更清晰的理清头绪 同步方法：synchronized关键字来声明 synchronized 方法。
多线程概述、简介及应用详解.pdf
最新发布
05-15
二、多线程简介 程序、进程与线程 程序：使用某种计算机语言编写的，为了完成某些功能的静态代码。例如，QQ、微信等都是程序。 进程：进行中的应用程序，是计算机分配资源的最小单位。程序在运行状态下才称之为进程...
多线程 hbase
03-03
多线程技术是Java程序性能优化的关键手段之一，当处理大数据量时，如HBase这样的系统尤其需要多线程来提升数据读写速度。本篇文章将深入探讨如何在HBase操作中有效地利用多线程。 一、HBase简介 HBase是一种列式...
多线程OpenCL
08-10
**正文** ...综上所述，多线程OpenCL技术结合了CPU的多线程能力和GPU的并行计算能力，为高效并行计算提供了强大的工具。理解和掌握这种技术，对于开发者来说是提升软件性能、挖掘硬件潜力的重要途径。
Java多线程yield心得分享
09-04
Java多线程编程是开发高并发应用的关键技术之一，其中`Thread.yield()`方法是一个重要的概念，用于线程之间的协作。这个方法允许当前正在执行的线程暂停执行，将其从运行状态变为可执行状态，从而可能让其他线程有...
Java多线程--基础概念与操作
github_40198042的博客
06-27 959
一、多线程相关概念1.1 什么是多线程        在早期的计算机中时没有操作系统的，计算机开启后只能执行一个程序，直到结束。操作系统的出现使得计算机可以同时执行多个程序，操作系统为每个程序分配不同的进程，每个进程拥有独立的句柄、资源等，使得计算机可以同时执行多个程序。但是进程的创建和销毁耗费的代价太大，因此衍生出线程的概念。允许在一个进程中创建多个线程，这些线程共享进程的资源，并且每个线程拥有...
多线程及锁的概念
yuranhzw123的博客
02-03 2472
首先先了解一下进程和线程的关系，还有它们的区别。进程是一个正在执行的程序，是向CPU申请资源的，进程之间数据相互独立，一个进程至少有一个线程。 线程是进程中的单一的顺序控制流程，也可以叫做最小控制单元，线程是进程中的执行单元，开启一个线程比开启一个进程更加节省资源。 多线程是多任务处理的一种特殊形式，多任务处理允许让电脑同时运行两个或者两个以上的程序，一般情况下，两种类型的多任务处理：基于进程
多线程的基本概念
zcm036200的博客
08-17 523
目录 一、进程、线程和纤程 二、多线程的实现方法 三、start和run方法的区别 四、线程的状态 五、sleep、wait、yield、join 六、多线程的三大特性 一、进程、线程和纤程 进程：比如我们下载QQ之后电脑上会有一个QQ.exe程序，双击打开它登录进去，这个时候就是一个进程。即操作系统分配内存资源的最小单位。 线程：一个程序里面不同的执行路径叫做一个线行。即CPU最小执行单元（内核空间）。其中线程与线程之间是不可见的。 ...
多线程_线程概述及多线程的意义
辐_射的博客
03-06 3155
1:要想了解多线程,必须先了解线程,而要想了解线程,必须先了解进程,因为线程是依赖于进程而存在的。 2:什么进程? 通过任务管理器我们看到了进程的存在。 而通过观察,我们发现只有运行的程序才会出现进程。 进程:正在运行的程序。 进程 是系统进行资源分配和调用的独立单位。每一个进程都有它自已的内存空间和系统资源。 3:多进程有什么意义? 单进程的计算机只能做一件事情,而我们现在的计算机
"多线程简介和在JAVA项目中的应用介绍
多线程简介及在 JAVA 项目中的应用 目录 1. 什么是多线程 2. 为什么使用多线程 3. 什么时候使用多线程 4. 什么地方使用多线程 5. JAVA 多线程简介 6. 如何使用多线程 7. 多线程在项目中的应用 8. 多线程使用总结 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值