多线程基础

最新推荐文章于 2024-09-13 17:30:19 发布
最新推荐文章于 2024-09-13 17:30:19 发布
阅读量796 收藏 18
点赞数 26
分类专栏： Java基础 多线程 并发 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42742845/article/details/141071076
版权
Java基础 同时被 3 个专栏收录
4 篇文章 0 订阅
订阅专栏
多线程
1 篇文章 0 订阅
订阅专栏
并发
1 篇文章 0 订阅
订阅专栏

线程的创建

1. 通过继承Thread类实现多线程

通过继承Thread类来自定义一个线程类, 并重写run()方法. run()方法是一个线程的线程体, 也就是开启这个线程后它要执行的部分. 之后, 直接在main方法中通过new()的方式创建两个线程实例, 再通过start()方法, 让这两个线程运行起来. 运行起来之后就开始执行run()方法中的代码了.

为了方便我们看到结果, 使用getName()方法来获取当前线程的name. 这个方法是父类Thread中的方法, 直接调用即可.

public class ThreadTest extends Thread {

    public ThreadTest() {
        System.out.println(this.getName());
    }

    /**
     * 线程的线程体
     */
    @Override
    public void run() {
        System.out.println(this.getName() + "线程开始");
        for (int i = 0; i < 20; i++) {
            System.out.println(this.getName() + " " + i);
        }
        System.out.println(this.getName() + "线程结束");
    }

    public static void main(String[] args) {
        System.out.println("主线程开始");
        // 创建线程
        ThreadTest t1 = new ThreadTest();
        ThreadTest t2 = new ThreadTest();
        // 启动线程
        t1.start();
        t2.start();
        System.out.println("主线程结束");
    }
}

2. 通过实现Runnable接口实现多线程

通过继承Thread类的方式确实可以帮助我们创建自己的线程, 但是由于java单继承的特点, 我们自定义的线程类无法再继承其他的类, 这样会给我们带来一些限制. 此时我们可以采取实现Runnable接口的方式创建我们自己的线程. 查看源码可知, Thread类本身也是继承了Runnable接口的.

// Thread类源码
public
class Thread implements Runnable {
    ...
}

Runnable接口中只有一个方法, 就是run()方法, 可以看出, 这就是我们多线程的核心方法.

// Runnable接口源码
public interface Runnable {
    public abstract void run();
}

在我们的测试类中, 依然是对run()方法的重写, 不同的是由于我们没有继承Thread类, 于是就没有了getName()方法. 不过也可以使用Thread.currentThread()方法得到当前的线程的对象实体, 再调用getName()方法就可以了.

Thread.currentThread()方法是Thread类中的一个静态方法, 返回的就是当前线程的对象实体.

// Thread类源码
/**
 * Returns a reference to the currently executing thread object.
 *
 * @return  the currently executing thread.
 */         
public static native Thread currentThread();

由于我们的测试类只是实现了Runnable接口, 所以它并没有start()方法, 那么怎么让它启动呢? 这时我们就需要把测试方法包装成Thread对象. 方式就是Thread t1 = new Thread(new RunnableTest());.

这里还有一点需要注意的是虽然我们的测试类的构造方法Runnable()是我们自定义线程的构造方法, 但是在我们new RunnableTest()时, 这个构造方法是在主线程(即main)中执行的, 也就是说line3这段代码的输出结果是main. 其原因就是这段代码是在main线程中执行的, 此时我们的自定义线程还没开启呢.

我们的自定义线程通过start()方法启动之后, 就开始执行run()方法, 在run()方法中(即线程体中)执行的Thread.currentThread().getName()得到的才是我们自定义线程的名字.

public class RunnableTest implements Runnable {
    public RunnableTest() {
        System.out.println(Thread.currentThread().getName());
    }
    /**
     * 当前线程的线程体
     */
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "线程开始");
        for (int i = 0; i < 20; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
        }
        System.out.println(Thread.currentThread().getName() + "线程结束");
    }
    public static void main(String[] args) {
        System.out.println("主线程开始");
        Thread t1 = new Thread(new RunnableTest());
        Thread t2 = new Thread(new RunnableTest());

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

        System.out.println("主线程结束");
    }
}

另外, 如果我们自定义的线程类只需要使用一次, 那么可以使用匿名内部类的方式书写如下:

Thread t1 = new Thread(new Runnable(){
    @Override
    public void run() {
        ...
    }
});

Runnable接口中只有一个方法, 这种接口我们称之为函数式接口, 那么就可以使用lambda表达式来书写. 如果方法体只有一行, {}都可以省略.

Thread t3 = new Thread(() -> {
    ...
});

线程的声明周期

在这里插入图片描述

新生状态(New)

用 new 关键字建立一个线程对象后，该线程对象就处于新生状态。处于新生状态的线程有自己的内存空间，通过调用 start 方法进入就绪状态。

就绪状态(Runnable)

处于就绪状态的线程已经具备了运行条件，但是还没有被分配到 CPU，处于“线程就绪队列”，等待系统为其分配 CPU。就绪状态并不是执行状态，当系统选定一个等待执行的 Thread 对象后，它就会进入执行状态。一旦获得 CPU，线程就进入运行状态并自动调用自己的 run 方法。有 4 中原因会导致线程进入就绪状态：

  1. 新建线程：调用 start()方法，进入就绪状态；

  2. 阻塞线程：阻塞解除，进入就绪状态；

  3. 运行线程：调用 yield()方法，直接进入就绪状态；

  4. 运行线程：JVM 将 CPU 资源从本线程切换到其他线程。

运行状态(Running)

在运行状态的线程执行自己 run 方法中的代码，直到调用其他方法而终止或等待某资源而阻塞或完成任务而死亡。如果在给定的时间片内没有执行结束，就会被系统给换下来回到就绪状态。也可能由于某些“导致阻塞的事件”而进入阻塞状态。

阻塞状态(Blocked)

阻塞指的是暂停一个线程的执行以等待某个条件发生（如某资源就绪）。有 4 种原因会导致阻塞：

  1. 执行 sleep(int millsecond)方法，使当前线程休眠，进入阻塞状态。当指定的时间到了后，线程进入就绪状态。

  2. 执行 wait()方法，使当前线程进入阻塞状态。当使用 nofity()方法唤醒这个线程后，它进入就绪状态。

  3. 线程运行时，某个操作进入阻塞状态，比如执行 IO 流操作read()/write()方法本身就是阻塞的方法)。只有当引起该操作阻塞的原因消失后，线程进入就绪状态。

  4. join()线程联合: 当某个线程等待另一个线程执行结束后，才能继续执行时，使用join()方法。

死亡状态(Terminated)

死亡状态是线程生命周期中的最后一个阶段。线程死亡的原因有两个。一个是正常运行的线程完成了它 run()方法内的全部工作； 另一个是线程被强制终止，如通过执行 stop()或 destroy()方法来终止一个线程（注：stop()/destroy()方法已经被 JDK 废弃，不推荐使用）。

当一个线程进入死亡状态以后，就不能再回到其它状态了。

线程的使用

1. 终止线程

如果我们想在一个线程中终止另一个线程我们一般不使用 JDK 提供的 stop()/destroy()方法(它们本身也被 JDK 废弃了)这种方式过于粗暴, 线程会直接挂掉, 就算有后续的收尾工作也不会执行。

通常的做法是提供一个 boolean 型的终止变量，当这个变量值为 false 时，则终止线程的运行。

public class StopThreadTest implements Runnable{

    private boolean flag = true;

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "线程开始");
        int i = 0;
        while(flag) {
            System.out.println(Thread.currentThread().getName() + " " + i++);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //模拟线程的收尾工作
        System.out.println(Thread.currentThread().getName() + "线程结束");
    }

    public void stop() {
        this.flag = false;
    }

    public static void main(String[] args) throws IOException {
        System.out.println("主线程开始");
        StopThreadTest st = new StopThreadTest();
        Thread t1 = new Thread(st);
        t1.start();
        System.in.read();
        st.stop();
        System.out.println("主线程结束");
    }
}

2. 暂停线程

sleep()方法

**作用: **让正在运行的线程休眠一段时间并进入阻塞状态, 等待休眠结束后再进入就绪队列.

public class SleepThreadTest implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "线程开始");
        for (int i = 0; i < 20; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
            try {
                // 让线程暂停, 并设置时间为1000, 单位是毫秒(millis)
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println(Thread.currentThread().getName() + "线程结束");
    }

    public static void main(String[] args) {
        System.out.println("主线程开始");
        Thread t0 = new Thread(new SleepThreadTest());
        t0.start();
        System.out.println("主线程结束");
    }
}

yield()方法

**作用: **让正在运行的线程停止运行, 让出cpu, 进入就绪队列排队.

注意: yield()方法是Thread类的一个静态方法. 使用yield()方法使线程重新排队后, 该线程有一定几率会被调度程序再次选中, 所以该方法让出cpu是有可能失败的.

public class YieldThreadTest implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            if (i == 0 && "Thread-1".equals(Thread.currentThread().getName())) {
                // 暂停线程让出cpu, 但是可能会失败
                Thread.yield();
            }
            System.out.println(Thread.currentThread().getName() + " " + i);
        }
    }

    public static void main(String[] args) {
        Thread t0 = new Thread(new YieldThreadTest());
        Thread t1 = new Thread(new YieldThreadTest());
        t0.start();
        t1.start();
    }
}

3. 联合线程

线程A邀请线程B优先执行, 在线程B执行完之后线程A才能继续执行, 类似于方法的嵌套调用. "邀请"的方式是调用线程B的join()方法.

join() 方法的使用

join()方法就是指调用该方法的线程在执行完 run()方法后，再执行 join ()方法后面的代码， 即将两个线程合并，用于实现同步控制.

在下面的实例代码中, 主线程(main)和在执行的过程中执行了t0.join(), 联合了Thread-0线程, 于是main线程停止执行, 并等待Thread-0执行完再接着执行. 于此同时Thread-1线程不受任何影响. 依然是与其他线程并发执行.

public class JoinTreadTest {
    public static void main(String[] args) throws InterruptedException{
        Thread t0 = new Thread(new ThreadA());
        Thread t1 = new Thread(new ThreadB());
        t0.start();
        t1.start();
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + " "+ i);
            if (i == 2) {
                t0.join();
            }
            Thread.sleep(1000);
        }
    }
}

class ThreadA implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
class ThreadB implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

联合线程实例

使用线程联合的方式实现同步.

public class JoinDemo {
    public static void main(String[] args) {
        System.out.println("爸爸和儿子买烟的故事");
        Thread t = new Thread(new FatherTread());
        t.start();
    }
}

class FatherTread implements Runnable {
    @Override
    public void run() {
        System.out.println("爸爸想抽烟, 发现烟抽完了");
        System.out.println("爸爸让儿子去买一包红塔山");
        Thread t = new Thread(new SonThread());
        System.out.println("等待儿子买烟回来");
        t.start();
        try {
            t.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
            System.out.println("儿子丢了, 爸爸出门找儿子");
            System.exit(1);
        }
        System.out.println("爸爸抽上了烟, 并把零钱给了儿子");
    }
}
class SonThread implements Runnable {
    @Override
    public void run() {
        System.out.println("儿子出门买烟");
        System.out.println("儿子买烟需要十分钟");
        for (int i = 0; i < 10; i++) {
            System.out.println("第" + i + "分钟");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

4. Thread类其他常用方法

4.1 获取线程名称

  • this.getName()获取当前线程名称, 适用于继承Thread类实现的多线程方式.
  • Thread.currentThread.getName()先获取当前线程的实例, 再获取当前线程名称.

4.2 设置线程名称

  • 通过构造方法设置线程名称

    Thread类有一个public Thread(String name)的构造方法, 子类继承Thread类之后, 可以在子类的构造方法的第一行调用父类的这个构造方法super(name)

  • 通过Thread类的setName()方法设置线程名称

    无论是通过继承Thread类, 还是通过实现Runnable接口实现的多线程, 都可以在线程对象创建完成后, 直接调用Thread类的普通方法setName()来为线程设置名称.

4.3 判断当前线程是否存活

thread.isAlive()方法: 判断当前线程是否处于活动状态.

线程创建并启动之后(执行thread.start()方法), 到执行完自己的run()(线程体)之前, 都属于活动状态.

线程的优先级

1. 什么是线程优先级

每一个线程都是有优先级的，我们可以为每个线程定义线程的优先级，但是这并不能保 证高优先级的线程会在低优先级的线程前执行。线程的优先级用数字表示，范围从 1 到 10， 一个线程的缺省优先级是 5。 Java的线程优先级调度会委托给操作系统去处理，所以与具体的操作系统优先级有关， 如非特别需要，一般无需设置线程优先级。

注意：线程的优先级，不是说哪个线程优先执行，如果设置某个线程的优先级高。那就 是有可能被执行的概率高。并不是优先执行。

2. 线程优先级的使用

  • thread.getPriority()方法可以获取线程的优先级
  • thread.setPriority()方法可以设置线程的优先级

**注意: **线程优先级必须在线程启动之前(start())设置, 启动之后设置是无效的.

守护线程

1. 什么是守护线程

在 Java 中有两类线程：

  • User Thread(用户线程)：就是应用程序里的自定义线程。

  • Daemon Thread(守护线程)：服务于用户线程的线程, 比如垃圾回收线程，就是最典型的守护线程。

    守护线程特点： 守护线程会随着用户线程死亡而死亡

2. 守护线程与用户线程的区别

用户线程，不随着主线程的死亡而死亡。

用户线程只有两种情况会死掉，

  1. 在run()方法执行过程中异常终止。
  2. 正常把run()方法执行完毕，线程死亡。

守护线程，随着用户线程的死亡而死亡，当用户线程死亡守护线程也会随之死亡.

3. 守护线程的使用

使用setDaemon()方法设置守护线程

public class DaemonThreadTest {
    public static void main(String[] args) {
        Thread t = new Thread(new UserThread());
        t.start();
    }
}


/**
 * 守护线程
 */
class DaemonThread implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

/**
 * 用户线程
 */
class UserThread implements Runnable {
    @Override
    public void run() {
        Thread daemonThread = new Thread(new DaemonThread());
        // 将该线程设为守护线程
        daemonThread.setDaemon(true);
        daemonThread.start();
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

线程同步

1. 什么是线程同步

同步是指程序中用于控制不同线程间操作发生相对顺序的机制。

1.1 线程冲突

当多个线程同时操作某个资源时很容易就会出现冲突. 如果多个线程同时执行写操作就容易出现覆盖的情况.

1.2 线程同步的概念

处理多线程问题时，多个线程访问同一个对象，并且某些线程还想修改这个对象。 这时候，我们就需要用到“线程同步”。 线程同步其实就是一种等待机制，多个需要同时 访问此对象的线程进入这个对象的等待池形成队列，等待前面的线程使用完毕后，下一个线程再使用.

2. 实现线程同步

2.1 synchronized关键字

由于同一进程的多个线程共享同一块存储空间，在带来方便的同时，也带来了访问冲突 的问题。Java 语言提供了专门机制以解决这种冲突，有效避免了同一个数据对象被多个线 程同时访问造成的这种问题。这套机制就是 synchronized 关键字。

// synchronized 语法结构： 
public synchronized void accessVal(int newVal); 

synchronized(锁对象){ 
    同步代码
}

synchronized 关键字使用时需要考虑的问题：

  • 需要对那部分的代码在执行时具有线程互斥的能力(线程互斥：并行变串行)。
  • 需要对哪些线程中的代码具有互斥能力(通过 synchronized 锁对象来决定)。 它包括两种用法：synchronized 方法和 synchronized 块。

2.2 synchronized关键字的使用

  • synchronized 方法

    通过在方法声明中加入 synchronized 关键字来声明，语法如下：

    public synchronized void method() {
    
}

    synchronized 在方法声明时使用：放在访问权限修饰符(public)之后,返回类型声明(void) 之前, 也可以放在最前面, 但是不太规范。这时同一个对象下synchronized 方法在多线程中执行时，该方法是同步的，即一次 只能有一个线程进入该方法，其他线程要想在此时调用该方法，只能排队等候，当前线程(就是在synchronized方法内部的线程)执行完该方法后，别的线程才能进入。

  • synchronized 块

    synchronized 方法的缺陷：如果直接将一整个方法声明为 synchronized 将会大大影响效率。

    Java 为我们提供了更好的解决办法，那就是synchronized块, 可以让我们精确地控制到具体的“成员变量”，缩小同步的范围，提高效率.

    synchronized(锁对象){ 
    ...
}

synchronized关键字不能被继承

按对象锁的类型分类
使用this作为锁

在不同线程中, 调用相同对象的synchronized(){} 会发生互斥.

本质是对同步代码所在的对象加锁.

  • 语法结构
synchronized(this) {
    // 同步代码
}
// 等同于对普通方法加synchronized
public synchronized void method() {
    
}
使用字符串作为锁

所有使用统一字符串为对象锁的synchronized(){}代码块都会同步.

本质是对字符串常量对象加锁

  • 语法结构
synchronized("String") {
    // 同步代码
}
使用Class作为锁

在不同的线程中, 使用统一Class对象的synchronized(){} 代码块会同步执行.

本质是对类的class对象加锁,

  • 语法结构
synchronized(XX.class) {
    // 同步代码
}
// 等同于对类的静态方法加synchronized修饰
public synchronized static void staticMethod() {
    // 同步代码
}

总结

无论是使用何种类型的对象锁, 本质都是对对象加锁, 字符串和类对象的本质也是对象, 在对象的内存结构中, 对象头的位置, 存储量该对象的锁信息, 加锁的实质就是修改这个锁信息, 当某个线程需要获取锁时, 会先判断对象是否已经加锁, 如果没有就自己加锁, 然后执行同步代码, 如果已被加锁, 就需要等待锁被释放, 再去尝试加锁.

使用自定义对象作为锁
按synchronized关键字的使用方式分类
  • 修饰普通方法: 锁当前对象
  • 修饰静态方法: 锁当前对象所属类的类对象
  • 包裹代码块: 小括号里写什么就对什么加锁

3. wait 和 notify

方法名所用
final void wait()表示线程一直等待, 直到得到其他线程通知
void wait(long timeout)线程等待指定的毫秒数
final void wait(long timeout, int nanos)线程等待指定的毫秒, 微秒时间
final void notify()唤醒一个处于等待状态的线程
final void notifyAll()唤醒同一个对象上, 所有调用wait()方法的线程, 优先级高的先运行

以上方法斗是java.lang.Object类的方法;

都只能在同步方法或者同步代码块中使用, 否则会抛出异常.

死锁

1. 死锁的概念

1.1 死锁的定义

多个线程由于竞争资源而造成的一种互相等待的状态, 若无外力作用, 这些线程将无法推进.

1.2 死锁产生的原因

  • 系统资源的竞争
  • 线程推进顺序不合理

1.3 死锁产生的必要条件

  • 互斥资源–在一段时间内只能被一个线程使用的资源, 具有排他性
  • 不可剥夺–线程获得的资源在使用完之前不能被其他线程强行夺走, 只能主动释放
  • 请求保持–线程已经保持了至少一个资源, 同时又在请求新的资源
  • 循环等待–这些陷入死锁的线程中存在一个循环等待链

| final void wait(long timeout, int nanos) | 线程等待指定的毫秒, 微秒时间 |
| final void notify() | 唤醒一个处于等待状态的线程 |
| final void notifyAll() | 唤醒同一个对象上, 所有调用wait()方法的线程, 优先级高的先运行 |

以上方法斗是java.lang.Object类的方法;

都只能在同步方法或者同步代码块中使用, 否则会抛出异常.

死锁

1. 死锁的概念

1.1 死锁的定义

多个线程由于竞争资源而造成的一种互相等待的状态, 若无外力作用, 这些线程将无法推进.

1.2 死锁产生的原因

  • 系统资源的竞争
  • 线程推进顺序不合理

1.3 死锁产生的必要条件

  • 互斥资源–在一段时间内只能被一个线程使用的资源, 具有排他性
  • 不可剥夺–线程获得的资源在使用完之前不能被其他线程强行夺走, 只能主动释放
  • 请求保持–线程已经保持了至少一个资源, 同时又在请求新的资源
  • 循环等待–这些陷入死锁的线程中存在一个循环等待链
Ethan_.
关注
专栏目录
多线程基础与基于多线程的简单聊天室
06-24
本压缩包“多线程基础与基于多线程的简单聊天室”提供了对多线程技术的实践理解和二次开发的基础。以下是关于这个主题的详细知识点： 1. **多线程的概念**：多线程是指在一个程序中同时执行多个不同的线程，每个...
多线程基础部分.md，学习代码
06-21
我们将围绕标题“多线程基础部分”展开，结合描述和标签，重点关注Java中的多线程、软件设计以及并发编程的相关概念。 首先，让我们理解什么是多线程。在计算机科学中，线程是程序执行的基本单位，一个进程可以包含...
C++ 多线程基础及 C++11 多线程库总结
生命在于折腾！
10-22 3601
1. 多线程基础 1.1 进程与线程 根本区别： 进程是操作系统资源分配的基本单位，线程是任务调度和执行的基本单位 开销方面： 每个进程都有自己独立的代码和数据空间，程序之间的切换开销较大。 线程可以看作是轻量级的进程，同一类线程共享代码和数据空间，每个线程都有自己独立的运行栈和程序计数器，线程之间切换开销小。 所处环境： 一个操作系统能同时运行多个进程（程序）。 在一个进程中，可以有多个线程同时执行。 内存分配方面： 系统在运行的时候会为每个进程分配不同的内存空间。 对线程而言，系统不会为
Java多线程基础知识
gldzzznb的博客
04-10 3351
这是我再次学习多线程知识的一个总结，对于刚刚接触的学习者是比较友好易懂的，便于快速的理解和掌握。
Java多线程基础（一）
计蒙不吃鱼的博客
07-19 5879
文章分两份，第一份主要内容为1-4点 1.多线程的概念 2.Java程序运行原理 3.实现多线程的2种方式 4.2种方式的区别 5.线程同步（同步锁） 6.同步线程之间的通讯 1.多线程的概念 （1）并发和并行 并行：多个CPU实例或是多台机器同时执行一段处理逻辑，是真正的同时。 并发：通过CUP调度算法，让用户看上去同时去执行，实际上从CPU操作层面并不是真正的同时。并发往往需要公共的资源，...
Qt 多线程基础及线程使用方式
热门推荐
weixin_49730048的博客
10-15 3万+
文章目录Qt 多线程操作2.线程类QThread3.多线程使用：方式一4.多线程使用：方式二5.Qt 线程池的使用 Qt 多线程操作 应用程序在某些情况下需要处理比较复杂的逻辑， 如果只有一个线程去处理，就会导致窗口卡顿，无法处理用户的相关操作。这种情况下就需要使用多线程，其中一个线程处理窗口事件，其他线程进行逻辑运算，多个线程各司其职，不仅可以提高用户体验还可以提升程序的执行效率。 Qt中使用多线程需要注意： Qt的默认线程为窗口线程（主线程）：负责窗口事件处理或窗口控件数据的更新； 子线程负责后台的业
头歌Educoder——Java高级特性 - 多线程基础（3）线程同步
赵士杰——成功并非一蹴而就，而是在持之以恒的努力中逐渐实现。
03-24 7775
文章目录第1关：并发编程的三个概念任务描述相关知识1.原子性2.可见性3.有序性编程要求题第2关：使用synchronized关键字同步线程任务描述相关知识并发编程什么时候会出现安全问题如何解决线程安全问题synchronized关键字synchronized代码块编程要求测试说明代码示例第3关：使用线程锁（Lock）实现线程同步任务描述2相关知识Lock接口lock()方法的正确使用编程要求代码示例第4关：使用volatile实现变量的可见性任务描述相关知识什么是 volatile 关键字volatile
EduCoder Java高级特性 - 多线程基础（3）线程同步
知足且上进，温柔而坚定
03-07 1万+
第1关：并发编程的三个概念 第2关：使用synchronized关键字同步线程 第3关：使用线程锁（Lock）实现线程同步，使用sleep（）函数解决了第三关线程随机导致的需要评测多次问题 第3关：使用线程锁（Lock）实现线程同步
Java多线程基础
m0_62946761的博客
05-17 3296
Java多线程基础知识
JAVA多线程基础
weixin_47600732的博客
03-19 4124
JAVA多线程基础 1.什么是并发原理？ 多线程：多线程允许我们“同时”执行多段代码。 线程是并发运行的，线程调度会统一规划CPU时间，将CPU的时间划分为若干片段，然后尽可能的均匀分配给所要并发运行的线程，每个线程在获取CPU时间片段后CPU就会运行它的任务，当时间片段用完后，Cpu会离开并执行获取到CPu时间片的线程，所以，所有线程并非真正的“同时”运行着代码，而是走走停停，这种微观上走走停停，在宏观上感觉是同步进行的现象称为“并发运行”。 2.创建线程Thread 1. 方式一：继承Thread并重写
EduCoder Java高级特性 - 多线程基础（1）使用线程
知足且上进，温柔而坚定
02-28 1万+
第1关：创建线程 任务描述 本关任务：创建一个Java线程执行特定任务。 编程要求 请仔细阅读右侧代码，根据方法内的提示，在Begin - End区域内进行代码补充，具体任务如下： 使用继承Thread类的方式创建一个名为 ThreadClassOne 的类，重写的run方法需要实现输出0-10之间的奇数，输出结果如下： 1 3 5 7 9； 使用实现Runnable接口的方式创建一个名为ThreadClassTwo的类，重写run方法，编写start方法，run方法需要实现打印0-
Java多线程干货系列（1）Java多线程基础编程开发技术
11-22
Java多线程是Java编程中的重要...以上内容仅涵盖了Java多线程基础编程的一部分知识点，实际开发中还需要关注更多的并发控制策略、性能优化和调试技巧。对于深入理解Java多线程，还需要学习和实践更多相关的高级特性。
java多线程基础知识
01-25
Java多线程基础知识 Java多线程基础知识是Java编程语言中的一项重要技术，用于提高程序的执行效率和响应速度。在这里，我们将详细介绍Java多线程基础知识的相关概念和技术。 一、程序、进程和线程 程序（Program...
spring事务详细讲解-深入浅出
小电玩
09-08 507
Spring 事务是本身就是对数据库的事务的支持，没有数据库的事务 Spring 是本身无法实现事务的。Spring只提供了统一事务管理接口，具体的实现还是由各数据库自己实现。在使用 Spring 事务时，可以通过注解或编程方式将需要进行事务管理的方法和代码块标记为事务性操作，当这些操作被执行时，Spring 会负责开启时根据当前环境中设置的隔离级别，调整数据库隔离级别。
Java多线程：深入探索与详细解析
m0_63550220的博客
09-08 1491
作为Java中的基本执行单元，线程是轻量级的进程，由线程ID、程序计数器、Java虚拟机栈、本地方法栈、和线程私有内存等部分组成。每个线程都有独立的执行路径，但共享进程的资源（如内存）。：进程是系统资源分配的基本单位，它包含了一个或多个线程以及这些线程运行所需的资源。在Java中，JVM（Java虚拟机）就是一个进程，而运行在JVM上的多个线程则共享JVM的内存空间。：并发指的是多个任务在同一时间段内交替执行，而并行则指的是多个任务在同一时刻真正同时执行。
自动生成不重复的订单id
最新发布
ClaireCheney的博客
09-13 113
【代码】自动生成不重复的订单id。
Java集合：Stack详解
yang_brother的博客
09-10 560
Java 中的Stack类是一个后进先出（LIFO, Last In First Out）的数据结构，它继承自Vector类。尽管Stack是一个可用的类，但它被认为是遗留的，并且在新代码中不推荐使用。通常建议使用Deque或ArrayDeque作为替代。
多线程基础与应用详解
"多线程基础ppt - 适合初学者的多线程入门教材，由闫益伟于2012.03.20编撰，作为STP项目组的培训资料" 在深入探讨多线程之前，我们首先要理解一些基本概念。程序是一系列按照特定顺序排列的计算机指令，它们被编写...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值