线程、多线程和线程池

最新推荐文章于 2025-07-01 13:02:48 发布

汉三姓胡

最新推荐文章于 2025-07-01 13:02:48 发布

阅读量898

点赞数 1

CC 4.0 BY-SA版权

分类专栏：面试

本文链接：https://blog.youkuaiyun.com/hnnd123/article/details/87860721

面试专栏收录该内容

5 篇文章

订阅专栏

开启线程的三种方式？
1）继承Thread类创建线程

2）实现Runnable接口创建线程

3）使用Callable和Future创建线程
Callable接口提供了一个call（）方法作为线程执行体，call()方法比run()方法功能要强大。
call()方法可以有返回值
call()方法可以声明抛出异常

线程和进程的区别？
进程是指程序执行时的一个实例。
线程是进程的一个实体。
进程——资源分配的最小单位，线程——程序执行的最小单位。
一个程序至少有一个进程,一个进程至少有一个线程
线程执行开销小，但不利于资源的管理和保护；
而进程正相反。

为什么要有线程，而不是仅仅用进程？
程序并不能单独运行，只有将程序装载到内存中，系统为它分配资源才能运行，而这种执行的程序就称之为进程。程序和进程的区别就在于：程序是指令的集合，它是进程运行的静态描述文本；进程是程序的一次执行活动，属于动态概念。
进程只能在一个时间干一件事，如果想同时干两件事或多件事，进程就无能为力了。
进程在执行的过程中如果阻塞，例如等待输入，整个进程就会挂起，即使进程中有些工作不依赖于输入的数据，也将无法执行。

run()和start()方法区别
start()：该方法是在当前线程中启动一个新的线程，而新启动的线程会调用run()方法，同时该方法不能重复调用；
run() ：该方法和普通的方法一样，可以重复执行，不会创建新的线程。

public class StartAndRunDemo {
	public static void main(String[] args) {
		Thread t1 = new  MyThread("thread_01");
		System.out.println("run() ....");
		t1.run();
		System.out.println("start() ....");
		t1.start();
		
		//run()方法可以重复执行
		//t1.run();
		//start()方法不能重复执行，重复执行会抛出java.lang.IllegalThreadStateException
		//t1.start();
		
	}
	
	static class  MyThread  extends Thread{
		public  MyThread(String name){
			super(name);
		}
		
		@Override
		public void run() {
			System.out.println(Thread.currentThread().getName() + " is running!");
		}
	}
 
}

输出的结果是：
 run() ....
 main is running!
 start() ....
 thread_01 is running!
 
原文：https://blog.youkuaiyun.com/tianmlin1/article/details/79054304

①在main方法中执行的run()方法不会创建新的线程，而在main方法中执行的start()方法会启动一个新的线程，新的线程会调用run方法
②run方法可以多次执行，但是start方法不允许多次执行，多次执行start()方法会抛出一个一个运行时异常java.lang.IllegalThreadStateException

如何控制某个方法允许并发访问线程的个数？
使用Semaphore控制某个方法允许并发访问的线程的个数
semaphore.acquire() 请求一个信号量，这时候的信号量个数-1（一旦没有可使用的信号量，也即信号量个数变为负数时，再次请求的时候就会阻塞，直到其他线程释放了信号量）
semaphore.release() 释放一个信号量，此时信号量个数+1

public class SemaphoreTest {
    private Semaphore mSemaphore = new Semaphore(5);
    public void run(){
        for(int i=0; i< 100; i++){
            new Thread(new Runnable() {
                @Override
                public void run() {
                    test();
                }
            }).start();
        }
    }
 
    private void test(){
        try {
            mSemaphore.acquire();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + " 进来了");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + " 出去了");
        mSemaphore.release();
    }
}

原文：https://blog.youkuaiyun.com/anhenzhufeng/article/details/70225415

示例中实例化了具有5个信号量的semaphore，保证只有5个线程在执行test方法

04-18 17:05:46.350 14192-14228/com.tongxt.myapplication I/System.out: Thread-1228 进来了
04-18 17:05:46.351 14192-14231/com.tongxt.myapplication I/System.out: Thread-1231 进来了
04-18 17:05:46.354 14192-14233/com.tongxt.myapplication I/System.out: Thread-1233 进来了
04-18 17:05:46.354 14192-14232/com.tongxt.myapplication I/System.out: Thread-1232 进来了
04-18 17:05:46.355 14192-14234/com.tongxt.myapplication I/System.out: Thread-1234 进来了

04-18 17:05:47.351 14192-14228/com.tongxt.myapplication I/System.out: Thread-1228 出去了
04-18 17:05:47.351 14192-14236/com.tongxt.myapplication I/System.out: Thread-1236 进来了
04-18 17:05:47.352 14192-14231/com.tongxt.myapplication I/System.out: Thread-1231 出去了
04-18 17:05:47.352 14192-14235/com.tongxt.myapplication I/System.out: Thread-1235 进来了
04-18 17:05:47.354 14192-14233/com.tongxt.myapplication I/System.out: Thread-1233 出去了
04-18 17:05:47.354 14192-14237/com.tongxt.myapplication I/System.out: Thread-1237 进来了
04-18 17:05:47.354 14192-14232/com.tongxt.myapplication I/System.out: Thread-1232 出去了
04-18 17:05:47.354 14192-14229/com.tongxt.myapplication I/System.out: Thread-1229 进来了
04-18 17:05:47.356 14192-14234/com.tongxt.myapplication I/System.out: Thread-1234 出去了
04-18 17:05:47.356 14192-14230/com.tongxt.myapplication I/System.out: Thread-1230 进来了
04-18 17:05:48.351 14192-14236/com.tongxt.myapplication I/System.out: Thread-1236 出去了

在Java中wait和seelp方法的不同；
一.java中的sleep()和wait()的区别;

对于sleep()方法，我们首先要知道该方法是属于Thread类中的。而wait()方法，则是属于Object类中的。

sleep()方法导致了程序暂停执行指定的时间，让出cpu该其他线程，但是他的监控状态依然保持者，当指定的时间到了又会自动恢复运行状态。

在调用sleep()方法的过程中，线程不会释放对象锁。

而当调用wait()方法的时候，线程会放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象调用notify()方法后本线程才进入对象锁定池准备获取对象锁进入运行状态。

public class TestD {

    public static void main(String[] args) {
        new Thread(new Thread1()).start();
        try {
            Thread.sleep(5000);
        } catch (Exception e) {
            e.printStackTrace();
        }
        new Thread(new Thread2()).start();
    }

    private static class Thread1 implements Runnable {
        @Override
        public void run() {
            synchronized (TestD.class) {
                System.out.println("enter thread1...");
                System.out.println("thread1 is waiting...");
                try {
                    // 调用wait()方法，线程会放弃对象锁，进入等待此对象的等待锁定池
                     TestD.class.wait();
                } catch (Exception e) {
                    e.printStackTrace();
                }
                System.out.println("thread1 is going on ....");
                System.out.println("thread1 is over!!!");
            }
        }
    }

    private static class Thread2 implements Runnable {
        @Override
        public void run() {
            synchronized (TestD.class) {
                System.out.println("enter thread2....");
                System.out.println("thread2 is sleep....");
                // 只有针对此对象调用notify()方法后本线程才进入对象锁定池准备获取对象锁进入运行状态。
                TestD.class.notify();
                // ==================
                // 区别
                // 如果我们把代码：TestD.class.notify();给注释掉，即TestD.class调用了wait()方法，但是没有调用notify()
                // 方法，则线程永远处于挂起状态。
                try {
                    // sleep()方法导致了程序暂停执行指定的时间，让出cpu该其他线程，
                    // 但是他的监控状态依然保持者，当指定的时间到了又会自动恢复运行状态。
                    // 在调用sleep()方法的过程中，线程不会释放对象锁。
                    Thread.sleep(5000);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                System.out.println("thread2 is going on....");
                System.out.println("thread2 is over!!!");
            }
        }
    }
}

这个没有注解掉:TestD.class.notify()的图片
在这里插入图片描述