线程（一）

于 2023-03-11 16:10:24 发布
阅读量396 收藏
点赞数
分类专栏： java 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44816731/article/details/129464900
版权

线程

1. 线程

定义：线程是进程的组成部分，不同的线程执行不同的任务，不同的功能模块，同时线程使用的资源师由进程管理，主要分配CPU和内存。

​ 在进程中，线程执行的方式是抢占式执行操作，需要考虑的是当前的线程是否持有CPU的执行权和等待权，同时关注线程的状态。

多线程：有了多线程，我们就可以让程序同时处理多个事件。作用能够快速提高效率。

并发和并行的区别

	并发：表示的是在同一时刻，多个任务在单个的CPU上的交替执行的操作。
	并行：表示的是在单位时间内，多个处理器或者多核处理器的同时处理的方式，是真正意义上的同时进行。
    串行：表示的是有N个任务，通过一个线程进行顺序的执行操作，由于任务中只存在一个任务，方法都是在一个线程的执行的，所以不存在线程的不安全的情况，也就是不存在临界区的问题。比如两个人排队使用一台电脑。

1.1 多线程的优点

有利于提高CPU的利用效率，允许单个程序创建多个并行执行的线程来完成各自的任务

1.2 多线程的缺点

  1. 线程也是程序，所以线程是需要进行内存的占用的，线程越多，内存的占用越多
  2. 多线程需要进行协调和管理，所以需要CPU时间跟踪线程
  3. 线程之间对于共享资源的访问是相互影响的，必须解决竞用共享资源的问题。

1.3 守护线程

	守护线程是运行在后台的，为其他的前台的线程提供服务的，也可以说守护线程是JVM中非守护线程的“佣人”一旦所有的线程都结束运行，守护线程会随着JVM进行运行操作。

2. 线程的创建

2.1 通过继承Thread类的方式

​ Tread类是线程类，一种反方是将类声明为Thread的子类的方式，该子类的应该通过重写run方法的方式来创建线程。

​ 使用的步骤格式：

  1. 自己定义一个类继承Thread
  2. 重写run方法
  3. 创建子类对象，而且进行线程的启动
class MyThread1 extends Thread {
    @Override
    public void run() {
        // 线程代码
    }
}

main() {
    // 实例化自定义继承 Thread 类子类对象
    MyThread1 mt1 = new MyThread1();
    
    // 利用继承父类 Thread 中的 start 方法，启动线程。【切记不可以直接调用 run 方法】
    mt1.start();
}

【重点】

​ 为什么我们通过调用start方法来执行run方法，而不是直接调用run方法

  1. 首先new一个Tread线程，线程进入到新创建的状态中，调用start方法，会启动一个线程并且将线程进入到就绪的状态，当分配到时间片的时候，就能够进行工作了。start() 方法会执行线程的准备工作，然后自己进行执行run() 方法的内容，这才是真正的多线程的工作。
  2. 直接执行run方法的时候，main方法会将其看做一个普通的反方进行执行操作，并不会在某个线程中去执行它，所以不是多线程的工作。

2.2 通过实现Runnable接口

多线程的创建的步骤：

  1. 自己定义一个类实现Runnable接口
  2. 重写里面的run方法
  3. 创建自己的类对象
  4. 创建一个Tread类的对象，Runnable作为参数传入，并且开启线程

Runnable 接口是一种函数式接口，@FuncationalInterface ，能够使用lambda表达式。

class MyThread2 implements Runnable {
	@Override
    public void run() {
        // 线程代码
    }
}

main() {
    /*
    可以利用 Thread 类构造方法，实例化目标线程对象，执行对应线程目标
    将 Runnable 接口的实现类对象作为 Thread 构造方法参数
    构造方法 Thread(Runnable target);
    	构造方法的作用是以 ：Runnable 接口实现类为当前线程的执行目标，new 关键字 + 构造方法实例化线程对象
    */
    Thread t1 = new Thread(new MyThread2());
    
    t1.start();
}

真实案例的代码实现：
 class MyThread1 extends Thread {
    @Override
    public void run() {
         for (int i = 0; i < 100; i++) {
           System.out.println("自定义线程继承 Thread 类型完成线程类");
            }
        }
    }

class MyThread2 implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("自定义线程遵从 Runnable 接口实现线程类");
        }
    }
}

/**
 * Thread 自定义线程类实现的两种方式
 *
 * @author Anonymous 2023/3/8 10:06
 */
public class Demo1 {
    public static void main(String[] args) {
        MyThread1 mt1 = new MyThread1();
        Thread mt2 = new Thread(new MyThread2());

        mt1.start();
        mt2.start();
        for (int i = 0; i < 100; i++) {
            System.out.println("main方法内容...");
        }
    }
}

2.3 通过实现Callable接口(有返回结果)

多线程的第三种的实现的方式：

  1. 创建一个 自定义 类实现java.util.concurrent包Callable接口
  2. 重写call方法（有返回值，表示的是多线程的运行的结果）
  3. 创建MyCallable的对象（表示多线程要进行执行的任务）
  4. 创建FutureTask的对象（作用是管理多线程的运行的结果）
  5. 创建Thread类的对象，并且进行启动的操作（表示线程）

【注意】：其中的callable是存在泛型的格式的，其中的泛型表示的是返回值的泛型

//方法步骤
public class MyCallable implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        /*
         * 用来求解1~100 的和
         */
        int sum = 0;
        for (int i = 0; i <= 100; i++) {
            sum += i;
        }
        return sum;
    }
}


// 测试实现操作
public class TestMain {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        /*
         * 1. 创建MyCallable的对象（表示的是多线程要执行的任务）
         */
        MyCallable myCallable = new MyCallable();

        /*
         2. 创建FutureTask的对象，作用是用来管理多线程的运行的结果
         */
        FutureTask<Integer> integerFutureTask = new FutureTask<>(myCallable);

        /*
         * 3. 创建线程的对象
         */
        Thread thread = new Thread(integerFutureTask);

        /*
            4.启动线程
         */
        thread.start();

        /*
         * 获取多线程的运行的结果
         */
        Integer integer = integerFutureTask.get();
        System.out.println(integer);


    }
}

总结

  1. Tread 继承的操作，编码比较简单，可以直接使用Tread类中的方法，可以拓展的可能性比较差，不能够继承其他的类
  2. 接口的方式是可拓展性是比较强的，实现接口的同时还可以继承其他的类，编程相对来说比较复杂，不能够直接使用Tread类中方法。

2.4 线程中操作方法

方法名称作用
String getName()获取指定线程对象的名称
void setName(String name)针对于线程的名称获取和设置
int getPriority()获取指定线程的优先级
void setPriority(int newPriority)获取指定线程的优先级 默认是5 只能够提供被执行的概率，不能确保一定会执行操作
final void setDaemon(boolean flag)设置指定线程为守护线程
boolean isDaemon()设置和判断当前线程是否为守护线程
static void sleep(long time)单位是ms强迫一个线程睡眠的时间，单位是毫秒级别的
static Thread currentThread();在哪一个线程代码中执行，获取当前线程代码对应的线程对象。
static void yield()出让线程，礼让线程的操作
static void join()插入线程、插队线程的操作
构造方法:
	Thread();
		过
	Thread(Runnable target);
		以 Runnable 接口实现类为当前线程的执行目标，new 关键字 + 构造方法实例化线程对象
	Thread(Runnable target, String threadName);
		以 Runnable 接口实现类为当前线程的执行目标，同时明确当前线程的名字，
	new 关键字 + 构造方法实例化线程对象

对于指定的方法进行分析的操作
    
	1. String getName()  ： 表示的是获取指定的线程的名称，如果没有设置名称，线程也会自动生成名称的，通过源码我们能够看到是this当前线程 + nextThreadNum(): 是一个变量的自动递增。
 	2. void setName(String name)：对于线程进行名字的设置除了调用方法的设置的方式之外，还能够通过调用构造方法的方式来进行实现：比如说Thread(String threadName)    以及   Thread(Runnable target, String threadName)两种方法来实现线程名称的命名。
    3.static Tread currentThread() ：获取当前线程的对象。细节是：当JVM虚拟机进行启动的时候，会自动的启动多条线程，其中有一条线程是main线程，它的作用是调用main方法，并且执行里面的代码，在以前的时候，我们所写的代码其实都是运行在main线程中
    4.static void sleep(long time)：那条线程执行到这个反方，那么那条线程就会在这里进行停留时间。方法的参数，就表示的是睡眠的时间，时间的单位毫秒。1s = 1000ms 当时间到了之后，线程会自动的醒来，继续执行下面的其他的代码。
    5.final void setDaemon(boolean flag) 当其他的非守护线程执行完毕之后，守护线程会陆续的结束，既当其他线程结束操作之后，守护线程也就没有存在的必要了。

/**
* 通过实现runnable接口实现线程的创建
*/
public class MyRunnable implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+"____"+i);
        }
    }
}


public class Demo1 {
    public static void main(String[] args) {
        /*
         * 创建线程需要执行的参数对象
         */
        Runnable runnable = new MyRunnable();

        /*
         *  创建线程对象
         */
        Thread thread = new Thread(runnable, "张三");
        Thread thread1 = new Thread(runnable, "李四");

        /*
         * 通过更改优先级的大小，提高线程优先运行的概率，不能够保证一定是优先执行的操作。
         */
        thread.setPriority(10);
        thread1.setPriority(6);


        /*
         * 进行线程的执行的操作，需要进行开启线程操作
         */
        thread.start();
        thread1.start();

    }
}

运行的结果：
李四____0
张三____0
张三____1
张三____2
张三____3
张三____4
张三____5
张三____6
张三____7
张三____8
张三____9
李四____1
李四____2
李四____3
李四____4
李四____5
李四____6
李四____7
李四____8
李四____9

2.5 线程的生命周期

sleep 方法会让线程睡眠，睡眠的时间到了之后，不会立刻执行下面的代码：不会直接执行，会进入到就绪的状态上，然后进行线程资源的抢夺，如果抢夺到资源后能够运行。

3. 线程安全

​ 线程安全的问题：对于线程安全来说，所有的隐患都是出现多个线程访问的情况下产生的，我们能够确保在多条线程访问的情况下，我们的程序能够按照我们预期的行为去执行。

​ 需求：某电影院中目前需要上映国产的大片，共有100张票，需要三个窗口进行售票的行为，请设计一个程序模拟电影院进行买票的行为。

// 采用继承的方式创建对象
/**
 * 通过继承的方式操作线程
 */
public class MyThread extends Thread{

    /*表示的是这个类中的所有的对象，都在共享tickets的数据
     */
    static int ticket = 0;

    @Override
    public void run() {
         while (true) {
             if (ticket < 100){

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

                 ticket ++ ;
                 System.out.println(getName()+"正在卖"+ticket+"张票");
             } else {
                 break;
             }
         }
    }
}

// 进行检验
public class Demo1 {
    /**
     *检验多线程的问题
     *
     * @param args
     */
    public static void main(String[] args) {

        /*
         * 1. 创建线程对象
         */
        MyThread myThread1 = new MyThread();
        MyThread myThread2 = new MyThread();
        MyThread myThread3 = new MyThread();

        /*
            通过调用方法起名字
         */
        myThread1.setName("窗口1");
        myThread2.setName("窗口2");
        myThread3.setName("窗口3");

        /*
        开启线程的操作
         */
        myThread1.start();
        myThread2.start();
        myThread3.start();

    }
}

运行的结果：
    ......
窗口1正在卖96张票
窗口3正在卖97张票
窗口1正在卖99张票
窗口2正在卖99张票
窗口3正在卖100张票
窗口1正在卖101张票
窗口2正在卖102张票
    分析：出现重复的数据卖出，同时出现数据的溢出操作

总结：在进行循环的时候，出现线程满足循环的条件，所以进行执行的操作，出现线程争夺资源的情况，所以造成的问题是关于线程的安全的问题。

3.1 同步代码块

为了解决上述的问题的情况，我们可以引入的方法是同步的代码块的操作，把操作共享数据的资源进行加锁的操作

特点

  1. 锁默认的是打开的关系，有一个线程进去，锁自动关闭
  2. 里面的代码全部执行完毕，线程出来，锁自动打开。
格式：
    synchronized(锁){
    	操作共享数据的代码
}

// 改进的代码操作如下所示：
public class MyThread extends Thread{

    /*表示的是这个类中的所有的对象，都在共享tickets的数据
     */
    static int ticket = 0;
    /**
    *
    针对于第一种的创建的方式，可能出现创建多种的线程对象，因此将之加上static 将数据共享   ，如果是对于方法二而言：创建的只有一种Runnable对象。而且是当做参数，创建线程的操作。因此不需要进行共享的声明。
    */

    @Override
    public void run() {
         while (true) {
             
             //此处是更改之后的数据的操作
             
             synchronized ("锁对象要求是唯一"){
                 if (ticket < 100){
    
                     try {
                         Thread.sleep(100);
                     } catch (InterruptedException e) {
                         e.printStackTrace();
                     }
    
                     ticket ++ ;
                     System.out.println(getName()+"正在卖"+ticket+"张票");
                 } else {
                     break;
                 }
             }
         
           
         }
    }
}

改进后的运行的效果是：
    ......
窗口3正在卖95张票
窗口2正在卖96张票
窗口2正在卖97张票
窗口3正在卖98张票
窗口1正在卖99张票
窗口3正在卖100张票

【重点操作】:

​ 在锁结构中，我们能够使用的过程中加上唯一的锁对象,对于锁对象的选择上来说

  1. 必须保证唯一的特性
  2. 通常是一个类内会设置一个独立的变量作为锁对象使用
  3. 包装类不得用于锁对象使用
  4. 当前类型的Class对象可以作为锁对象，但是不推荐

3.2 同步方法

  1. 使用的关键字是synchronized

  2. 限制对应的方法是有且只能通过一个线程进入到方法中执行目标的任务

  3. 重点进行区分的是有static修饰的方法是静态方法，需要进行考虑的是当前锁对象的情况，以及同步范围的情况。

同步方法的格式：
    修饰符 synchronized 返回值类型 方法名称（方法参数）{
    
}

1.同步方法是锁住方法中的所有的代码
2. 锁对象不能够自己指定

 // 注意：非静态的同步方法对象是当前调用方法的对象 -> this
public synchronized void sale() {...}

// 静态同步方法锁对象是当前类.class  类名.class 唯一的锁对象的特征
public static synchronized void staticSale() {...}
3.2.1 同步方法的范围

非静态的成员方法使用的是 synchronized 同步的约束，同步的范围

重点：通过当前的实例化对象作为锁对象，实例化对象调用任意 synchronized 修饰的同步方法，所有其他的 synchronized 同步方法，一律不能够进行执行的操作

java中经常使用的是：
    	ArrayList 和 Vector 
		StringBuilder 和 StringBuffer
		HashMap 和 HashTable

​ 静态的成员方法使用 synchronized 同步进行约束的操作，锁对象是 类名.class .无论那一条线程，任何一个对象来执行目标方法，都会被 类名.class 锁住，其他的任意的线程，任意的对象，都无法执行所有其他 static 修饰的 synchronized 约束的同步方法。

例子一：
    
public static synchronized void test1() {
    for (int i = 0; i < 10; i++) {
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Test1 方法");
    }
}

/*
等价于
synchronized (TypeB.class) {
    for (int i = 0; i < 10; i++) {
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Test1 方法");
    }
}
 */

例子二：
    电影院售票的操作套路
    
  采用的是通过实现接口的方式来创建线程 
public class MyRunnable implements Runnable{
int ticket = 0;

/**
 * 执行的套路是：
 *  1. 循环
 *  2. 同步代码块
 *  3.判断共享数据是否到了末尾，到末尾的情况
 *  4. 判断共享数据是否到了末尾，没有到末尾的情况
 */

@Override
public void run() {
	while (true) {
		synchronized (MyRunnable.class) {
			if (ticket == 100){
				break;
			} else {
				ticket ++;
				System.out.println(Thread.currentThread().getName()+"买了第"+ticket+"张票");
			}
		}
	}
}
}



更改成为同步方法的格式为：
public class MyRunnable implements Runnable{

    int ticket = 0;

    /**
     * 执行的套路是：
     *  1. 循环
     *  2. 同步代码块
     *  3.判断共享数据是否到了末尾，到末尾的情况
     *  4. 判断共享数据是否到了末尾，没有到末尾的情况
     */

    @Override
    public void run() {
        while (true) {
            if (extracted()) break;
        }
    }

    /**
     * 其中的锁对象是惟一的，其中的对象表示的是this，即为当前的对象
     *
     * @return
     */
    private synchronized boolean extracted() {
        if (ticket == 100){
            return true;
        } else {
            ticket ++;
            System.out.println(Thread.currentThread().getName()+"买了第"+ticket+"张票");
        }
        return false;
    }
}



通过创建接口对象，并且将接口对象作为参数进行传入的操作
     */
public class TicketDemo {
    public static void main(String[] args) {
        /**
         * 通过接口的实现，来进行操作，将接口名作为参数，创建线程
         */
        Runnable runnable = new MyRunnable();

        Thread thread0 = new Thread(runnable);
        Thread thread1 = new Thread(runnable);
        Thread thread2 = new Thread(runnable);

        thread0.setName("窗口1");
        thread1.setName("窗口2");
        thread2.setName("窗口3");

        thread0.start();
        thread1.start();
        thread2.start();


    }
}

3.3 Lock锁

  1. Lock 实现提供的比 synchronized 方法和语句可以获取更为广泛的锁定操作
  2. Lock中提供了获的锁和释放锁的方法
    1. void lock() 获得锁
    2. void unlock() 释放锁
  3. lock接口是不能够进行直接的实例化操作的，这里采用的它的实现类ReentrantLock 来实例化 ReentrantLock的构造方法。类ReentrantLock() 创建一个类ReentrantLock的实例。
  4. 总结： 手动上锁，手释放锁。
手动锁的结构是：
    
static Lock mylock = new ReentrantLock();
mylock.lock;

try{
    
}finally{
    mylcok.unlock();
    // 如果在临界区的代码抛出一个异常，锁必须释放。否则其他的线程将永远阻塞。
    
    
}
这个结构的优点是确保任何时刻，都只有一个线程进入临界区，一旦一个线程锁定了锁对象，其他的任何线程都无法通过lock语句，当其他的语句调用lock语句的时候，他们会暂停，直到第一个线程释放这个锁对象。

出现的问题：
    1. 创建三个线程对象，lock对象的创建是在类里面
    2. 所以出现的是三种不同的锁，所以有可能出现的是没有加锁成功
    3. 改正的方法可以在前面加上  static 修饰符

public class MyThread extends Thread{

    /*表示的是这个类中的所有的对象，都在共享tickets的数据
     */
    static int ticket = 0;

    Lock lock = new ReentrantLock();

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

             /*
               调用获得锁的方法操作,开始上锁
              */
             lock.lock();
             if (ticket < 100){
                 try {
                     Thread.sleep(100);
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }
                 ticket ++ ;
                 System.out.println(getName()+"正在卖"+ticket+"张票");
             } else {
                 break;
             }
             // 关锁的操作
             lock.unlock();
         }
    }
}

public class Demo1 {
    /**
     *检验多线程的问题
     *
     * @param args
     */
    public static void main(String[] args) {

        /*
         * 1. 创建线程对象
         */
        MyThread myThread1 = new MyThread();
        MyThread myThread2 = new MyThread();
        MyThread myThread3 = new MyThread();
        /*
            通过调用方法起名字
         */
        myThread1.setName("窗口1");
        myThread2.setName("窗口2");
        myThread3.setName("窗口3");

        /*
        开启线程的操作
         */
        myThread1.start();
        myThread2.start();
        myThread3.start();

    }
}

改进之后的作用：
 

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 通过继承的方式操作线程
 */
public class MyThread extends Thread{

    /*表示的是这个类中的所有的对象，都在共享tickets的数据
     */
    static int ticket = 0;

    static Lock lock = new ReentrantLock();

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

             /*
               调用获得锁的方法操作,开始上锁
              */
             lock.lock();
             
             try {
                 if (ticket < 100){
                     Thread.sleep(100);
                     ticket ++ ;
                     System.out.println(getName()+"正在卖"+ticket+"张票");
                 } else {
                     break;
                 }
             } catch (InterruptedException e) {
                 e.printStackTrace();
             } finally {
	              // 关锁的操作
                 lock.unlock();
             }
            
         }
    }
}

3.4 死锁（错误）

​ 死锁实际上是：指的是两个或者两个以上的进程在执行的过程中，由于竞争资源或者由于彼此的铜线而造成的一种阻塞的现象。若没有外力的作用，它们无法推进下去。

3.4.1 死锁的四个必要的条件
  1. 互斥条件：在一定的时间某种资源只有一个线程占用。如果此时还有其他的进程请求资源，就只能够等待，直到占有资源的进程用完释放
  2. 占有且等待条件：指进程已经保持至少一个资源，但是又提出了新的资源的请求，而且该资源已经被其他进程占用，此时请求进程阻塞，但是对于自己已经获得的其他的资源保持不放
  3. 不可抢占资源：别人已经占有额某项资源，你不能够因为自己也需要该资源，就去把别人的资源抢过来。
  4. 循环等待的条件：若干个进程之间形成一种头尾相接的循环等待的资源关系。
3.4.2 如何避免死锁
  1. 避免一个线程同时获得多个锁
  2. 避免一个线程在锁内同时占用多个资源，尽量保持每个锁只占用一种资源
  3. 尝试使用定时锁，使用lock.tryLock(timeout)来代替使用内部锁机制

3.5 线程安全

  • 临界资源：共享资源（同一个对象），一次只可以有一个线程操作，才能够保证准确性
  • 原子操作：不可拆分的步骤，被视为一个整体，其中的步骤不能够被打乱。

3.6 线程不安全

  1. 完整的步骤可能会被破坏
  2. 线程内的数据可能会被别的线程修改

举例

public class Printer extends Thread{

    // 锁需要是同一对象
    private Object obj = new Object();

    // 打印机1号
    public synchronized void print1() {
        //synchronized (obj){
        System.out.print(1+" ");
        System.out.print(2+" ");
        System.out.print(3+" ");
        System.out.print(4+" ");
        System.out.print("\r\n");
        //}
    }


    // 打印机2号
    public synchronized void print2() {
        //synchronized (obj) {
        System.out.print("一 ");
        System.out.print("二 ");
        System.out.print("三 ");
        System.out.print("四 ");
        System.out.print("\r\n");
        //}
    }
}

public class Demo1 {
    public static void main(String[] args) {
        Printer printer = new Printer( );

        // 线程1
        new Thread(() -> {
            while(true){
                printer.print1();
            }
        }).start();

        // 线程2
        new Thread(() -> {
            while(true){
                printer.print2();
            }
        }).start();
    }
}
小白搬砖2024
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
线程生命周期
weixin_43178406的博客
09-14 3万+
本文主要介绍了线程生命周期，希望能对学习线程的同学们有所帮助。 文章目录 1. 综述 2. 线程的生命周期
多线程一，什么是多线程，创建多线程的几种方式
世上哪有什么岁月静好,不过是有人替你负重前行
04-11 2万+
1 多线程相关概念 并发（Concurrent）：在操作系统中，是指一个时间段中有几个程序都处于已启动运行到运行完毕之间，且这几个程序都是在同一个处理机上运行。 同一时刻只能有一条指令执行，但多个进程指令被快速的轮换执行，使得在宏观上具有多个进程同时执行的效果，但在微观上并不是同时执行的，只是把时间分成若干段，使多个进程快速交替的执行。 并行（Parallel）：当系统有一个以上CPU时，当一个CPU执行一个进程时，另一个CPU可以执行另一个进程，两个进程互不抢占CPU资源，可以同时进行，这种方式我们称之为
多线程(一)：创建线程和线程的常用方法
热门推荐
人不风流枉少年
09-01 24万+
一：为什么要学多线程 应付面试 ：多线程几乎是面试中必问的题，所以掌握一定的基础知识是必须的。 了解并发编程：实际工作中很少写多线程的代码，这部分代码一般都被人封装起来了，在业务中使用多线程的机会也不是很多(看具体项目)，但是作为一个高级程序员如果不会多线程是说不过去的。 二：进程与线程 进程 进程是资源（CPU、内存等）分配的基本单位，它是程序执行时的一个实例。程序运行时系统...
Java多线程超详解
weixin_44797490的博客
06-11 14万+
引言 随着计算机的配置越来越高，我们需要将进程进一步优化，细分为线程，充分提高图形化界面的多线程的开发。这就要求对线程的掌握很彻底。 那么话不多说，今天本帅将记录自己线程的学习。 线程的相关API //获取当前线程的名字 Thread.currentThread().getName() 1.start():1.启动当前线程2.调用线程中的run方法 2.run():通常需要重写Thread类中的此...
SpringBoot多线程一个事务
weixin_43842467的博客
04-29 9270
最近工作中遇到了一个问题 由于某个批量功能执行时间实在太慢 于是想着使用多线程的方法加速 但是运行了之后发现 他们不存在于一个事务中，想要一个报错 全体回滚暂时不明白该怎么实现 相关伪代码 @Transactional public void test() throws InterruptedException { CountDownLatch countDown...
Java 多线程 终止线程的4中方式
java小猿成长记的博客
08-15 5403
多线程 上篇是线程的生命周期，那这次来分享下，终止线程的几种方式。 文章目录多线程1、正常运行结束2. 使用退出标志退出线程3、Interrupt方法结束线程4.stop()方法终止线程（不安全）1.sleep()和wait()区别：2.start()和run()的区别总结 1、正常运行结束 所谓正常运行结束，我的理解就是程序正常运行结束，线程自动结束。 2. 使用退出标志退出线程 一般run()方法执行完，线程就会正常结束，然而腻，常常有些线程是伺服线程。他们需要长时间的运行，只有在外部某些条件满足
【Java多线程】停止线程
一定要站在自己热爱的生活里闪闪发光
10-03 5万+
目录 1. 停止线程的方法 2. 判断线程是否是停止状态 3. 能停止的线程——异常法 4. 在沉睡中停止 5. 能停止的线程——暴力停止 6. 方法stop()与java,lang.ThreadDeath异常 7. 使用return停止线程 1. 停止线程的方法 在Java中有以下3种方法可以终止正在进行的线程： 1）使用退出标志，使线程正常退出，也就是当run方法完成后线程终止。 2）使用stop方法强行终止线程，但是不推荐使用这个方法，因为stop和suspend及resum
Java（通过继承Thread类的方式创建两个线程，在Thread构造方法中指定线程的名字“线程一”、“线程二”，并将这两个线程的名字打印出来。）
爱学习的JackYang的博客
11-30 8229
public class Double { public static void main(String[] args){ Mythread one=new Mythread(); Mthread two=new Mthread(); one.setName("线程一"); two.setName("线程二"); one.start(); two.start(); }...
一 线程基础
大佛拈花的博客
03-24 1万+
文章目录一、并行和并发二、进程和线程1.进程1.1 进程概念1.2 API操作2.线程2.1 线程概念2.2 线程调度2.3 多线程优势三、创建线程1.继承Thread2.实现Runnable3.匿名内部类四、Runnable和Thread的区别 一、并行和并发 并行：是指并排行走或者同时实施。是指两个或者多个事件同时发生。 并发：同时发生，可是和并行不一样的是在宏观层面上来看是同时发生，微观上其实还是交替执行。是指两个或者多个事件在同一事件片区执行。宏观上看起来同时执行。 并发是两个队列交替使用一台咖
万字图解Java多线程
qq_35598736的博客
09-06 6万+
前言 java多线程我个人觉得是javaSe中最难的一部分，我以前也是感觉学会了，但是真正有多线程的需求却不知道怎么下手，实际上还是对多线程这块知识了解不深刻，不知道多线程api的应用场景，不知道多线程的运行流程等等，本篇文章将使用实例+图解+源码的方式来解析java多线程。 文章篇幅较长，大家也可以有选择的看具体章节，建议多线程的代码全部手敲，永远不要相信你看到的结论，自己编码后运行出来的，才是自己的。 什么是java多线程? 进程与线程 进程 当一个程序被运行，就开启了一个进程， 比如启动了qq，w.
打开一个线程_打开一个线程_
10-03
在IT领域，线程是操作系统中的一个重要概念，它代表了程序执行的单一顺序控制流。在多线程环境中，一个进程可以包含多个并发执行的线程，这些线程共享同一块内存空间，允许它们高效地协作完成任务。LabVIEW，全称...
Java中断一个线程操作示例
08-25
Java中断一个线程操作示例 Java中断一个线程操作是指在某个线程正在执行任务时，强制其停止当前操作的行为。Java提供了多种方式来中断一个线程，包括interrupt()、isInterrupted()和interrupted()函数。这些函数的...
多线程的另一个例子
08-09
利用线程池开多个线程在linux下运行
线程封装类
05-18
在多线程环境中，一个进程可以包含多个并发执行的线程，这些线程共享进程的资源，使得程序能同时处理多个任务。在VC++（Visual C++）环境下，我们可以自定义线程类来更好地管理和控制线程的行为。 "线程封装类"的...
python 多线程重启方法
09-19
1. **为每个线程设置名字**：通过`setName()`方法，我们可以给线程一个独特的名字，比如用线程的工作内容来命名，这样在检查线程状态时更容易辨认。 2. **获取当前线程对象**：使用`threading.enumerate()`函数，...
C#停止线程的方法
09-03
首先，C#并没有提供直接的“Stop”方法来结束一个线程，因为这样做可能会导致数据不一致性和资源泄露。因此，推荐使用协作式的方式来停止线程，即让线程自己检查是否应该停止执行。这通常通过使用`System.Threading....
【线程 01】线程含义以及启动第一个线程
12-21
线程是最小的执行单元，而进程最少由一个线程组成 如何调度进程和线程，由操作系统决定，程序与用户无法决定 模块 1. _thread 模块 （低级模块，C） 2. threading 模块 （高级模块） import threading import time...
python 如何停止一个死循环的线程
01-19
换句话说，就是进程中的最小执行单位就是线程，并且一个进程中至少有一个线程。 那什么是多线程？提到多线程这里要说两个概念，就是串行和并行，搞清楚这个，我们才能更好地理解多线程。 所谓串行，其实是相对于单条...
C# 跨线程访问UI线程控件
01-20
C# 跨线程访问UI线程控件 ...第一种：使用控件自带的Invoke或者BeginInvoke方法。 Task.Factory.StartNew(() => { this.button1.Invoke(new Action(() => { this.button1.Text = hello world; })
c++多线程一个线程死掉会影响其他线程吗
最新发布
05-12
如果一个线程死掉，它不会直接影响其他线程的执行，但是如果这个线程持有一些共享资源，比如锁或者共享内存，那么其他线程可能会被阻塞等待这些资源的释放，从而影响整个程序的性能和正确性。 为了避免这种情况，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值