创建线程的三种方式、线程运行原理、常见方法、线程状态

最新推荐文章于 2024-07-29 14:22:26 发布
最新推荐文章于 2024-07-29 14:22:26 发布
阅读量1.6k 收藏 2
点赞数 1
分类专栏： Java并发编程 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ZSA222/article/details/123239303
版权

文章目录

1.创建线程的三种方式

1. 继承Thread类并重写run方法。
2. 实现Runnable接口，然后实现其run方法。
3. 通过Callable和Future创建线程。

将我们希望线程执行的代码放到 run 方法中，然后通过 start 方法来启动线程，start 方法首先为线程的执行准备 好系统资源，然后再去调用run方法。

1.1 继承Thread类并重写run方法

  • 定义Thread类的子类，并重写该类的run方法，该run方法的方法体就代表了线程要完成的任务。因此把run()方法称为执行体(线程体)。
  • 创建Thread子类的实例，即创建了线程对象。
  • 调用线程对象的start()方法来启动该线程。
  • Java不允许多继承。
/**
 * @ClassName MyThread
 * @author: shouanzh
 * @Description 继承Thread类创建线程类 （extends）
 * @date 2022/3/2 20:26
 */
@Slf4j
public class MyThread extends Thread{

	// 通过构造函数传递参数
	private String name;
    public MyThread(String name) {
        this.name = name;
    }

    @Override
    public void run() {
        // 具体任务逻辑
        System.out.println("继承Thread类创建线程类...");
        log.info("继承Thread类创建线程类...");
    }
}

/**
 * @ClassName CreateThread
 * @author: shouanzh
 * @Description 测试
 * @date 2022/3/2 20:29
 */
public class CreateThread {

    public static void main(String[] args) {

        MyThread myThread = new MyThread("T1");
        myThread.setName("T1");
        
		MyThread myThread2 = new MyThread("T2");
        myThread.setName("T2");
        // 启动线程
        myThread.start();
        myThread2.start();

    }

}

1.2 使用Runnable配合Thread

  • 定义Runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。
  • 创建 Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象。
  • 调用线程对象的start()方法来启动该线程。
  • Runnable接口支持多继承
/**
 * @ClassName RunnableThreadTest
 * @author: shouanzh
 * @Description 使用Runnable配合Thread
 * @date 2022/3/2 20:38
 */
@Slf4j
public class RunnableThreadTest implements Runnable{

	// 通过变量和方法传递数据
	private String name;
    public void setName(String name) {
        this.name = name;
    }

    @Override
    public void run() {
        // 创建线程任务
        System.out.println("继承Thread类创建线程类...");
        log.info("继承Thread类创建线程类...");
    }
}

/**
 * @ClassName CreateThread
 * @author: shouanzh
 * @Description 测试
 * @date 2022/3/2 20:29
 */
public class CreateThread {

    public static void main(String[] args) {

        RunnableThreadTest runnableThread = new RunnableThreadTest();

		// Runnable可以实现多个相同的程序代码的线程去共享同一个资源
        Thread  thread = new Thread(runnableThread);
        Thread  thread2 = new Thread(runnableThread);

        thread.start();
        thread2.start();

    }

}

1.3 通过Callable和FutureTask创建线程

  • 创建Callable接口的实现类，并实现call()方法，该call()方法将作为线程执行体，并且有返回值。
  • 创建Callable实现类的实例，使用FutureTask类来包装Callable对象，该FutureTask对象封装了该Callable对象的call()方法的返回值。（FutureTask是一个包装器，它通过接受Callable来创建，它同时实现了Future和Runnable接口。）
  • 使用FutureTask对象作为Thread对象的target创建并启动新线程。
  • 调用FutureTask对象的get()方法来获得子线程执行结束后的返回值
/**
 * @ClassName CallableThreadTest
 * @author: shouanzh
 * @Description 通过Callable和FutureTask创建线程
 * @date 2022/3/2 20:46
 */
public class CallableThreadTest implements Callable<String> {

    @Override
    public String call() throws Exception {
        return "hello word";
    }
}

**
 * @ClassName CreateThread
 * @author: shouanzh
 * @Description 测试
 * @date 2022/3/2 20:29
 */
public class CreateThread {

    public static void main(String[] args) throws ExecutionException, InterruptedException {

        CallableThreadTest callableThread = new CallableThreadTest();

        FutureTask<String> futureTask = new FutureTask<>(callableThread);

        Thread thread = new Thread(futureTask,"T1");

        thread.start();

		// 调用FutureTask对象的get()方法来获得子线程执行结束后的返回值
        String result = futureTask.get();

        System.out.println(result);

    }

}

2.Runnable和Thread的区别

Runnable与Thread，前者的实现方式是实现其接口即可，后者的实现方式是继承其类。两者实现方式带来最明显的区别就是，由于Java不允许多继承，因此实现了Runnable接口可以再继承其他类，但是Thread明显不可以。

Runnable可以实现多个相同的程序代码的线程去共享同一个资源，而Thread不可以？

以经典的卖票案列：总共只有5张动车票了，有2个窗口在卖。

1. Runnable方式：

/**
 * @ClassName RunnableThreadTest
 * @author: shouanzh
 * @Description 使用Runnable配合Thread
 * @date 2022/3/2 20:38
 */
@Slf4j
public class RunnableThreadTest implements Runnable {
    
    private int ticket = 5;
    
    @Override
    public void run() {
        while (true) {
            System.out.println("Runnable ticket = " + ticket--);
            if (ticket < 0) {
                break;
            }
        }
    }
}

/**
 * @ClassName CreateThread
 * @author: shouanzh
 * @Description 测试
 * @date 2022/3/2 20:29
 */
public class CreateThread {

    public static void main(String[] args) throws ExecutionException, InterruptedException {

        RunnableThreadTest runnableThread = new RunnableThreadTest();

        // Runnable可以实现多个相同的程序代码的线程去共享同一个资源
        Thread  thread = new Thread(runnableThread);
        Thread  thread2 = new Thread(runnableThread);

        thread.start();
        thread2.start();

    }

}

运行结果：

Runnable ticket = 5
Runnable ticket = 3
Runnable ticket = 2
Runnable ticket = 1
Runnable ticket = 0
Runnable ticket = 4

Process finished with exit code 0

一个任务可以启动多个线程，通过Runnable方式实现的线程，实际是开辟一个线程，将任务传递进去，由此线程执行。可以实例化多个 Thread对象，将同一任务传递进去，也就是一个任务可以启动多个线程来执行它。这些线程执行的是同一个任务，所以他们的资源是共享。

2. Thread方式：

**
 * @ClassName MyThread
 * @author: shouanzh
 * @Description 继承Thread类创建线程类 （extends）
 * @date 2022/3/2 20:26
 */
@Slf4j
public class MyThread extends Thread{

    private int ticket = 5;

    @Override
    public void run() {
        while (true) {
            System.out.println("Runnable ticket = " + ticket--);
            if (ticket < 0) {
                break;
            }
        }
    }
}

测试:
方式一：

因为一个线程只能启动一次，通过Thread实现线程时，线程和线程所要执行的任务是捆绑在一起的。也就使得一个任务只能启动一个线程，不同的线程执行的任务是不相同的，所以没有必要，也不能让两个线程共享彼此任务中的资源。

/**
 * @ClassName CreateThread
 * @author: shouanzh
 * @Description 测试
 * @date 2022/3/2 20:29
 */
public class CreateThread {

    public static void main(String[] args) throws ExecutionException, InterruptedException {

        // 每个线程都独立，不共享资源，每个线程都卖出了5张票，总共卖出了10张。
        MyThread myThread1 = new MyThread();
        MyThread myThread2 = new MyThread();

        myThread1.start();
        myThread2.start();

    }

}

运行结果

Runnable ticket = 5
Runnable ticket = 4
Runnable ticket = 3
Runnable ticket = 2
Runnable ticket = 1
Runnable ticket = 0
Runnable ticket = 5
Runnable ticket = 4
Runnable ticket = 3
Runnable ticket = 2
Runnable ticket = 1
Runnable ticket = 0

Process finished with exit code 0

方式二：

/**
 * @ClassName CreateThread
 * @author: shouanzh
 * @Description 测试
 * @date 2022/3/2 20:29
 */
public class CreateThread {

    public static void main(String[] args) throws ExecutionException, InterruptedException {

        
        MyThread myThread = new MyThread();

        Thread myThread2 = new Thread(myThread);
        Thread myThread1 = new Thread(myThread);

        myThread1.start();
        myThread2.start();

    }
}

运行结果

Runnable ticket = 5
Runnable ticket = 3
Runnable ticket = 2
Runnable ticket = 1
Runnable ticket = 0
Runnable ticket = 4

Process finished with exit code 0

其中方式一创建了两个MyThread对象，每个对象都有自己的ticket成员变量，当然会多卖。
方式二只创建了一个Thread对象,效果和Runnable一样。
实现Runable只是方便资源共享。当然继承Thrad也可以资源共享。

3.Thread类源代码剖析

  • Thread 类也实现了 Runnable接口,因此实现了Runnable 接口中的run方法。
    在这里插入图片描述
    在这里插入图片描述

  • 构造方法
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

  • 当使用第一种方式来生成线程对象时，我们需要重写 run 方法，因为 Thread 类的run 方法此时什么事情也不做。

  • 当使用第二种方式来生成线程对象时，我们需要实现 Runnable 接口的run 方法，然后使用 new Thread(new MyThread()) MyThread 已经实现了Runnable接口,来生成线程对象，这时的线程对象的run方法 会调用 MyThread 类的run方法，这样我们自己编写的run 方法就执行了。

4.线程运行原理

4.1 栈与栈帧

我们都知道JVM中由堆，栈，方法区所组成，其中栈内存是给谁用的呢？其实就是线程，每个线程启动 后，虚拟机就会为其分配一块栈内存。

  • 每个栈由多个栈帧(Frame)组成，对应着每次方法调用时所占用的内存
  • 每个线程只能有一个活动栈帧，对应着当前正在执行的那个方法

在这里插入图片描述
每个线程下的栈都是私有的，因此每个线程都有自己各自的栈，并且每个栈里面都有很多栈帧，栈帧的大小主要由局部变量表 和 操作数栈决定的

在这里插入图片描述

栈帧debug

/**
 * @ClassName TestFrame
 * @author: shouanzh
 * @Description TestFrame
 * @date 2022/3/2 23:28
 */
public class TestFrame {
    public static void main(String[] args) {
        method1(10);
    }

    public static void method1(int x) {

        int y = x + 1;

        Object object = method2();

        System.out.println(object);

    }

    public static Object method2() {
        Object object = new Object();
        return object;
    }
}

在这里插入图片描述
method2()执行完出栈
在这里插入图片描述
method1()执行完出栈
在这里插入图片描述
结束整个代码的运行
在这里插入图片描述

4.2 线程上下文切换（Thread Context Switch)

因为以下一些原因导致 cpu 不再执行当前的线程，转而执行另一个线程

  • 线程的 cpu 时间片用完
  • 垃圾回收(STW)
  • 有更高优先级的线程需要运行
  • 线程自己调用了 sleep、yield、wait、join、park、synchronized、lock 等方法

当Thread Context Switch发生时，需要由操作系统保存当前线程的状态，并恢复另一个线程的状态，Java 中对应的概念就是程序计数器（Program Counter Register），它的作用是记住下一条 jvm 指令的执行地址，是线程私有的

  • 线程的状态包括程序计数器、虚拟机栈中每个栈帧的信息，如局部变量、操作数栈、返回地址等
  • Context Switch 频繁发生会影响性能

5.Thread的常见方法

在这里插入图片描述
在这里插入图片描述

5.1 调用start 与 run方法的区别

  • 直接调用 run() 是在主线程中执行了 run()，没有启动新的线程
  • 使用 start() 是启动新的线程，通过新的线程间接执行 run()方法中的代码
@Slf4j
public class CreateThread {

    public static void main(String[] args) {

        Thread thread = new Thread("T1"){
            @Override
            public void run() {
                log.info("T1...");
            }
        };

        // 使用 start() 是启动新的线程，通过新的线程间接执行 run()方法中的代码
        thread.start(); // 2022-03-03 20:49:49 [T1] - T1...

        // 直接调用 run() 是在主线程中执行了 run()，没有启动新的线程
        thread.run(); // 2022-03-03 20:49:19 [main] - T1...

    }

}

5.2 sleep 与 yield

在这里插入图片描述
sleep的状态

@Slf4j
public class CreateThread {

    public static void main(String[] args) throws InterruptedException {

        Thread thread = new Thread("T1"){
            @SneakyThrows
            @Override
            public void run() {
                Thread.sleep(2000);
                log.info("T1...");
            }
        };

        thread.start();
        // T1的线程先执行了，这时T1的状态为RUNNABLE
        log.info("T1的State：{}",thread.getState()); // T1的State：RUNNABLE

        // 主线程休眠
        Thread.sleep(500);

        log.info("T1的State：{}",thread.getState()); // T1的State：TIMED_WAITING

    }

}

在这里插入图片描述
sleep的打断

@Slf4j
public class CreateThread {

    public static void main(String[] args) throws InterruptedException {

        Thread thread = new Thread("T1"){
            @Override
            public void run() {
                try {
                    log.info("T1 enter sleep...");
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    log.info("T1 wake up ...");
                    e.printStackTrace();
                }
            }
        };

        thread.start();

        Thread.sleep(1000);

        log.info("interrupt...");
        thread.interrupt();

    }

}

在这里插入图片描述
TimeUnit

TimeUnit.SECONDS.sleep(1);

yield使cpu调用其它线程，但是cpu可能会再分配时间片给该线程；
而sleep需要等过了休眠时间之后才有可能被分配cpu时间片

在这里插入图片描述

5.3 线程优先级

  • 线程优先级会提示（hint）调度器优先调度该线程，但它仅仅是一个提示，调度器可以忽略它,
  • 如果 cpu 比较忙，那么优先级高的线程会获得更多的时间片，但 cpu 闲时，优先级几乎没作用
thread.setPriority(Thread.MAX_PRIORITY);

5.4 join方法详解

等待调用join() 的线程结束。

@Slf4j
public class CreateThread {

    static int r = 0;

    public static void main(String[] args) {

        log.debug("开始");

        Thread t1 = new Thread(() -> {
            log.debug("开始");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            log.debug("结束");
            r = 10;
        },"t1");

        t1.start();
        t1.join();
        // 这里如果不加t1.join(), 此时主线程不会等待t1线程给r赋值, 主线程直接就输出r=0结束了
        // 如果加上t1.join(), 此时主线程会等待到t1线程执行完才会继续执行.(同步), 此时r=10;
        log.debug("结果为:{}", r);
        log.debug("结束");

    }

}

如果加上t1.join(), 此时主线程会等待到t1线程执行完才会继续执行.(同步), 此时r=10;
在这里插入图片描述
这里如果不加t1.join(), 此时主线程不会等待t1线程给r赋值, 主线程直接就输出r=0结束了
在这里插入图片描述

图解

在这里插入图片描述

下图, 因为开辟了t1线程. 此时程序中有两个线程; main线程和t1线程; 此时在main线程中调用t1.join, 所以main线程只能阻塞等待t1线程执行完. t1线程在1s后将r=10, t1线程执行完, 此时main线程才会接着执行

在这里插入图片描述
有时效的join(long n)

@Slf4j
public class CreateThread {

    static int r = 0;

    public static void main(String[] args) throws InterruptedException {

        log.debug("开始");

        Thread t1 = new Thread(() -> {
            log.debug("开始");
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            log.debug("结束");
            r = 10;
        },"t1");

        t1.start();
        t1.join(1000);
        // 这里如果不加t1.join(), 此时主线程不会等待t1线程给r赋值, 主线程直接就输出r=0结束了
        // 如果加上t1.join(), 此时主线程会等待到t1线程执行完才会继续执行.(同步), 此时r=10;
        log.debug("结果为:{}", r);
        log.debug("结束");

    }

}

在这里插入图片描述

5.5 interrupt 方法详解

该方法用于打断 sleep，wait，join的线程, 在阻塞期间cpu不会分配给时间片

  • 如果是打断因sleep、 wait 、join方法而被阻塞的线程，会将打断标记置为false
  • 如果一个线程在在运行中被打断，打断标记会被置为true

打断sleep的线程，会清空打断状态，以 sleep为例

@Slf4j
public class CreateThread {

    public static void main(String[] args) throws InterruptedException {

        Thread t1 = new Thread(() -> {
            try {
                log.info("sleep...");
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"t1");

        t1.start();
        Thread.sleep(500);
        log.debug("111是否被打断？{}",t1.isInterrupted());
        t1.interrupt();
        log.debug("222是否被打断？{}",t1.isInterrupted());
        Thread.sleep(500);
        log.debug("222是否被打断？{}",t1.isInterrupted());
        log.debug("主线程");
    }
}

在这里插入图片描述

打断正常运行的线程
如果一个线程在在运行中被打断，打断标记会被置为true

@Slf4j
public class CreateThread {

    public static void main(String[] args) throws InterruptedException {

        Thread t1 = new Thread(() -> {
            while(true) {
                boolean interrupted = Thread.currentThread().isInterrupted();
                if(interrupted) {
                    System.out.println("被打断了, 退出循环");
                    break;
                }
            }
        }, "t1");

        t1.start();
        Thread.sleep(1000);
        System.out.println("interrupt");
        t1.interrupt();
        System.out.println("打断标记为: "+t1.isInterrupted());

    }

}

在这里插入图片描述

5.6 设计模式-两阶段终止模式

在这里插入图片描述
在这里插入图片描述
代码举例：

public class Test7 {
	public static void main(String[] args) throws InterruptedException {
		Monitor monitor = new Monitor();
		monitor.start();
		Thread.sleep(3500);
		monitor.stop();
	}
}

class Monitor {

	Thread monitor;

	/**
	 * 启动监控器线程
	 */
	public void start() {
		//设置线控器线程，用于监控线程状态
		monitor = new Thread() {
			@Override
			public void run() {
				//开始不停的监控
				while (true) {
                    //判断当前线程是否被打断了
					if(Thread.currentThread().isInterrupted()) {
						System.out.println("处理后续任务");
                        //终止线程执行
						break;
					}
					System.out.println("监控器运行中...");
					try {
						//线程休眠
						Thread.sleep(1000); // 情况1 阻塞打断
						System.out.println("记录日志"); // 情况二：正常运行线程被打断
					} catch (InterruptedException e) {
						e.printStackTrace();
						//如果是在休眠的时候被打断，不会将打断标记设置为true，这时要重新设置打断标记
						Thread.currentThread().interrupt();
					}
				}
			}
		};
		monitor.start();
	}

	/**
	 * 	用于停止监控器线程
	 */
	public void stop() {
		//打断线程
		monitor.interrupt();
	}
}

5.7 interrupt 打断 park

@Slf4j
public class CreateThread {

    public static void main(String[] args) throws InterruptedException {

        Thread t1 = new Thread(() -> {
            log.info("park");
            LockSupport.park();
            log.info("uppark");
            log.info("打断状态{}",Thread.currentThread().isInterrupted());
            
            // log.info("打断状态{}",Thread.interrupted());
			// LockSupport.park(); // 打断状态为 true 时 无效 Thread.interrupted() 清除打断标记
			log.info("uppark");
        }, "t1");

        t1.start();
        Thread.sleep(1000);
        System.out.println("interrupt");
        t1.interrupt();
        
    }
}

在这里插入图片描述

5.8 不推荐使用的方法

在这里插入图片描述

5.9 主线程与守护线程

默认情况下， Java 进程需要等待所有线程都运行结束，才会结束。有一种特殊的线程叫做守护线程，只要其 它非守护线程运行结束了，即使守护线程的代码没有执行完，也会强制结束。

代码举例

@Slf4j
public class CreateThread {

    public static void main(String[] args) throws InterruptedException {

        Thread t1 = new Thread(() -> {
            while (true) {
                // 判断当前线程是否被打断了
                if (Thread.currentThread().isInterrupted()) {
                    System.out.println("处理后续任务");
                    //终止线程执行
                    break;
                }
            }
            log.info("结束");
        }, "Daemon");

        t1.setDaemon(true);
        t1.start();

        Thread.sleep(1000);

        log.info("结束");
    }

}

在这里插入图片描述

  • 垃圾回收器线程就是一种守护线程
  • Tomcat 中的 Acceptor 和 Poller 线程都是守护线程，所以 Tomcat 接收到 shutdown 命令后，不会等待它们处理完当前请求

5.10 sleep、yield、wait、join 对比

  • sleep，join，yield，interrupted是Thread类中的方法
  • wait/notify是object中的方法
  • sleep 不释放锁、释放cpu
  • join 释放锁、抢占cpu
  • yiled 不释放锁、释放cpu
  • wait 释放锁、释放cpu

6.线程状态

6.1 操作系统-五种状态

从操作系统方面描述

在这里插入图片描述
在这里插入图片描述

6.2 线程-六种状态

这是从 Java API 层面来描述的
根据Thread.State 枚举，分为六种状态

在这里插入图片描述
在这里插入图片描述

代码举例：

@Slf4j(topic = "c.TestState")
public class TestState {
    public static void main(String[] args) {

        // new 状态 没有调用start（）
        Thread t1 = new Thread("t1") {
            @Override
            public void run() {
                log.debug("running...");
            }
        };

        // runnable 状态
        Thread t2 = new Thread("t2") {
            @Override
            public void run() {
                while(true) {

                }
            }
        };
        t2.start();

        // TERMINATED
        Thread t3 = new Thread("t3") {
            @Override
            public void run() {
                log.debug("running...");
            }
        };
        t3.start();

        // timed_waiting 显示阻塞状态
        Thread t4 = new Thread("t4") {
            @Override
            public void run() {
                synchronized (TestState.class) {
                    try {
                        Thread.sleep(1000000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        t4.start();

        // waiting 状态
        Thread t5 = new Thread("t5") {
            @Override
            public void run() {
                try {
                	// 等待t2结束。一直等待
                    t2.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        t5.start();

        // blocked 状态
        Thread t6 = new Thread("t6") {
            @Override
            public void run() {
                synchronized (TestState.class) {
                    try {
                        Thread.sleep(1000000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        t6.start();

        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        log.debug("t1 state {}", t1.getState());
        log.debug("t2 state {}", t2.getState());
        log.debug("t3 state {}", t3.getState());
        log.debug("t4 state {}", t4.getState());
        log.debug("t5 state {}", t5.getState());
        log.debug("t6 state {}", t6.getState());
    }
}

在这里插入图片描述

7.应用之统筹规划

在这里插入图片描述

在这里插入图片描述

代码实现

/**
 * @ClassName Test5
 * @author: shouanzh
 * @Description 应用之统筹
 * @date 2022/3/4 21:50
 */
@Slf4j(topic = "c.Test")
public class Test5 {

    public static void main(String[] args) {

        //  洗水壶 烧水 串行
        Thread t1 = new Thread(() -> {
            log.debug("洗水壶");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            log.debug("烧水");
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"王昊");

        //  洗茶壶 洗茶杯 拿茶叶
        Thread t2 = new Thread(() -> {

            log.debug("洗茶壶");

            log.debug("洗茶杯");

            log.debug("拿茶叶");


            try {
                // 等待t1结束
                t1.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            // t1结束
            log.debug("泡茶");

        },"小赵");

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

在这里插入图片描述

Zhang_960110
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Linux 多线程原理深剖
qq_61500888的博客
12-24 3万+
带你一命通关 Linux 多线程原理 三十分钟手撕底层内涵
Java线程状态运行原理解析
08-25
Java线程状态运行原理解析 Java线程状态运行原理解析是Java编程语言中一个非常重要的概念，涉及到线程的生命周期、状态转换、线程间通信等方面。下面我们将对Java线程状态运行原理进行详细的分析和解释。 线程状态...
java 创建线程的三种方式、创建线程池的四种方式
SmileTimLi的博客
02-23 4万+
概要： java创建线程的三种方式： 继承Thread类创建线程类 实现Runnable接口 通过Callable和Future创建线程 java创建线程池的四种方式： newCachedThreadPool 创建一个可缓存的线程池，如果线程池长度超过处理需求，可灵活回收空闲线程，若无可回收，则新建线程 newFixedThread...
线程创建的三种方式和线程池创建的四种方式
chaochao2113的博客
07-17 1万+
线程创建的方式和区别 1.继承Thread类 （1）创建Thread类的子类，并重写该类的run方法，该run方法的方法体就代表了线程要完成的任务。因此把run()方法称为执行体。 （2）创建了Thread子类的实例，即创建了线程对象。 （3）调用线程对象的start()方法来启动该线程。 package com.thread; public class Thread01 { public static void main(String[] args) { MyThread01 t
创建多线程的三种方式
好好学习
07-24 3203
并发与并行 进程 是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个进程;进程也是程序的一次执行过程，是系统运行程序的基本单位;系统运行一个程序即是一个进程从创建、运行到消亡的过程。 线程 线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。 简而言之:一个程序运行后至少有一个进程，一个进程中可以包含多个线程 线程调度: 分时调度 所有线程轮流使用CPU的使用权，平均分
【面试精讲】Java线程6种状态和工作原理详解，Java创建线程的4种方式
小明的Java问道之路
03-10 8607
Java线程6种状态和工作原理详解，Java创建线程的4种方式
创建线程三种方法
一个菜鸡的博客
06-20 4694
null :池中一直保持的线程的数量，即使线程空闲也不会释放。除非设置了 allowCoreThreadTimeOut *池中允许的最大的线程数当线程数大于核心线程数的时候，线程在最大多长时间没有接到新任务就会终止释放， 最终线程池维持在 corePoolSize 大小时间单位阻塞队列，用来存储等待执行的任务，如果当前对线程的需求超过了 corePoolSize大小，就会放在这里等待空闲线程执行。创建线程的工厂，比如指定线程名等。
多线程开发实战：Java实现多线程四种方式及相关方法原理
陈橘又青的博客
07-02 3万+
本文带大家了解Java实现多线程的四种方法以及实现多线程的重要注意事项和难点！
Java 创建线程的三种方式总结
卜大爷的博客
12-03 2万+
Java 创建线程的三种方式总结 我们在开发中，为了提高程序的运行效率，经常会使用多线程的方式来实现并发操作。 那么创建线程有几种方式呢？ 1、继承 Thread 类 直接继承 Thread 即可实现多线程。Thread 本质上也是实现了 Runnable 接口，线程启动的唯一方法是通过 Thread 类的 start() 实例方法实现的。start() 方法调用时，系统才会真正创建一个新线程，并执行 run() 方法，它是一个native方法。 class MyThread extends Th
【多线程与高并发】- synchronized锁的认知
热门推荐
qq_43843951的博客
02-19 22万+
synchronized 是 Java 语言的一个关键字，它允许多个线程同时访问共享的资源，以避免多线程编程中的竞争条件和死锁问题。
深入分析JVM中线程的创建和运行原理
小小默：进无止境
01-07 5345
【1】基础知识 JVM中的线程是和OS中的线程一一对应的，操作系统负责调度所有的线程，因此在不同的平台上，Java线程的优先级有所不同。 在JVM中除了应用线程，还有其他的一些线程用于支持JVM的运行，这些线程可以被划分为以下几类： VM Thread：负责JVM在安全点内的各种操作，这些操作（诸如自动内存管理、取消偏向锁、线程dump、线程挂起等等）在执行过程中需要JVM处于这样一个状态——堆...
Java多线程 线程状态原理详解
08-25
1. **NEW**：新建状态，线程被创建但尚未调用`start()`方法。 2. **RUNNABLE**：运行状态，线程可能正在执行，也可能在等待CPU调度。 3. **BLOCKED**：阻塞状态，线程正等待获取一个监视器锁以便进入同步代码块或...
C#线程委托实现原理及方法解析
12-16
【C#线程委托实现原理及方法解析】 在C#编程中，多线程是实现并发执行任务的关键技术。在Windows应用程序开发中，尤其是涉及到Windows窗体（Windows Forms）时，线程的管理显得尤为重要。本文将深入探讨C#线程的...
在Python 的线程中运行协程的方法
01-20
在一篇文章 理解Python异步编程的基本原理 这篇文章中，我们讲到，如果在异步代码里面又包含了一段非常耗时的同步代码，异步代码就会被卡住。 那么有没有办法让同步代码与异步代码看起来也是同时运行的呢?方法就是...
java static方法 引用static属性 存在线程安全问题-原理分析
12-21
Java中的静态方法和静态属性是线程安全问题的常见触发点。线程安全问题通常发生在多个线程同时访问和修改共享资源时，如果没有适当的同步机制，可能会导致数据不一致或出现不可预测的结果。 首先，我们要理解`...
使用hutool工具判断字符串是否全部是字母(包括大小写)，java判断字符串是否全部是字母(包括大小写)
最新发布
qq_43700885的博客
07-29 265
1.导入hutool的maven依赖。2.复制一下代码执行。
golang 接口
m0_70982551的博客
07-24 1050
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
java判断邮箱地址是否正确，使用hutool工具判断邮箱地址是否正确
qq_43700885的博客
07-29 113
1.导入hutool的maven依赖。2.直接复制一下代码运行。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 573
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值