Java线程基础知识汇总（超详细版）

最新推荐文章于 2024-01-29 10:00:00 发布

杨树林_spring

最新推荐文章于 2024-01-29 10:00:00 发布

阅读量384

点赞数 3

文章标签： java python 开发语言

本文链接：https://blog.csdn.net/HSQdePYZ/article/details/131721454

版权

进程与线程

什么是进程？

进程是指在计算机中运行的程序的实例。它是操作系统进行资源分配和调度的基本单位。一个进程可以包含多个线程，每个线程都共享该进程的资源，如内存、文件和打开的网络连接等。每个进程都有自己的地址空间，即独立的内存区域。

什么是线程？

线程是进程内的执行单元，也是CPU的最小执行单元。一个进程可以包含多个线程，每个线程执行不同的任务。线程共享进程的资源，包括内存、文件和打开的网络连接等。线程之间通过共享内存进行通信，因此比进程间通信更高效。由于线程共享同一进程的地址空间，所以多线程之间的切换更快。

例如：我们启动JVM运行一个Java程序，其实就是启动了一个 JVM 的进程。在JVM的进程中，又包含了main ：主线程、Reference Handler：清理线程、Finalizer：线程（用于调用对象的finalize()方法）等线程。

线程与进程的区别？

根本区别：进程是操作系统资源分配的基本单位，而线程是处理器任务调度和执行的基本单位；
资源开销：每个进程都有独立的代码副本和数据空间，进程之间的切换，资源开销较大；线程可以看做轻量级的进程，每个线程都有自己独立的运行栈和程序计数器，线程之间切换，资源开销小；
内存分配：同一进程内的所有线程共享本进程的内存空间和资源；进程之间的内存空间和资源相互独立；
影响关系：一个进程崩溃后，在保护模式下不会对其他进程产生影响；一个线程崩溃，会导致整个进程退出。所以多进程要比多线程健壮；
执行过程：每个独立的进程有程序运行的入口和程序出口。但是线程不能独立执行，必须依存在应用程序（进程）中，由应用程序提供多个线程执行控制；
包含关系：一个进程内包含有多个线程，在执行过程，线程的执行不是线性串行的，而是多条线程并行共同完成；

单线程与多线程

单线程：单线程指的是程序中只有一个主线程在执行任务。在单线程模型中，任务按顺序依次执行，每个任务必须等待前一个任务完成后才能执行。当一个任务发生阻塞（如等待I/O操作或进行复杂计算）时，整个程序都会被阻塞，无法执行其他任务。单线程模型简单，易于编写和调试，但其执行效率受限于单个线程的处理能力。

多线程：多线程指的是程序中同时存在多个线程，并发地执行不同的任务。每个线程独立执行，可以同时进行多个任务。多线程模型可以充分利用多核处理器和资源，提高程序的性能和响应速度。不同的线程可以并行执行独立的任务，当某个线程发生阻塞时，其他线程仍然可以继续执行，不会阻塞整个程序。多线程编程需要注意线程安全、同步和数据共享等问题，避免出现竞态条件和死锁等并发问题。

线程的四种创建方式

为放方便整理，以下方法均采用匿名继承、匿名实现来完成。

1.方式一：继承 java.lang.Thread 类（线程子类）

//匿名子类
StringBuffer sb = new StringBuffer();
Thread t1 = new Thread() {
	@Override
	public void run() {
		for(char i ='A';i<='E';i++) {
			sb.append(i);
		}
	}
};

2.方式二:实现 java.lang.Runnable 接口(线程执行类)

Thread t2 = new Thread( new Runnable() {		
	@Override
	public void run() {
		for(char i ='a';i<='e';i++) {
			sb.append(i);
		}
	}
});

3.实现 java.util.concurrent.Callable 接口,允许子线程返回结果、抛出异常

Thread t3 = new Thread(new FutureTask<String>(new Callable<String>() {
	@Override
	public String call() throws Exception {
		for(int i = 1;i<=5;i++) {
			sb.append(i);
		}
		return sb.toString();
	}	
}));

4.线程池

线程池是线程中非常重要的一个知识点，此处不做详细介绍，只通过线程池创建一个线程对象。

ExecutorService executorService = Executors.newFixedThreadPool(1);
executorService.execute(new Runnable() {	
	@Override
	public void run() {
		String[] s= {"@","#","$","%","！"};
		for(int i =0;i<s.length;i++) {
			sb.append(s[i]);
		}
	}
});

5.线程的启动

通过调用Thread实例的start()方法启动新线程。
start()方法内部调用了一个private native void start0()方法,native修饰符表示这个方法是由JVM虚拟机内部的C代码实现的本地方法,由JVM根据当前操作系统进行本地实现。

Thread t1 = new Thread();
t1.start();

当线程启动后，它将在自己的执行路径上执行run()方法中的代码。

线程的休眠与优先级

线程的休眠

要使线程进入休眠状态，你可以使用Thread.sleep()方法。它使当前线程暂停执行一段指定的时间，然后再继续执行。
当线程调用 Sleep 后，它会进入阻塞状态，不会占用 CPU 资源。在指定的时间到达之前，线程不会被唤醒。Sleep 不会释放锁，因此其他线程无法访问被当前线程锁住的资源。

Thread.sleep()方法有两种重载形式：

sleep(long millis)：接受一个以毫秒为单位的时间参数，表示线程要休眠的时间长度。
sleep(long millis, int nanos)：接受一个以毫秒为单位和一个以纳秒为单位的时间参数，表示线程要休眠的时间长度。（不常使用）

 public static void main(String[] args) {
        System.out.println("主线程开始执行。。。");
        try {
            // 主线程休眠5秒
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

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

线程的优先级

在线程中,通过setPriority(int n)设置线程优先级,范围是1-10,默认为 5。
优先级高的线程被操作系统调度的优先级较高(操作系统对高优先级线程,调度更频繁)

Thread t1 = new MyThread() {
	@Override
	public void run() {
		for(char i ='A';i<='E';i++) {
			sb.append(i);
		}
	}
};
Thread t2 = new Thread( new Runnable() {		
	@Override
	public void run() {
		for(char i ='a';i<='e';i++) {
			sb.append(i);
		}
	}
});
 t1.setPriority(8); // 设置数字线程优先级=8
 t2.setPriority(1); // 设置字母线程优先级=1
// 启动子线程
t1.start();
t2.start();

注意:并不能代表,通过设置优先级来确保高优先级的线程一定会先执行，只是会提高一定的优先级。

线程的状态

在Java程序中,一个线程对象通过调用start()方法启动线程,并且在线程获取CPU时,自
动执行run()方法。run()方法执行完毕,代表线程的生命周期结束。
在整个线程的生命周期中,线程的状态有以下6种:

new:新建状态，新创建的线程，此时尚未调用start()方法；
Runnable:运行状态，运行中的线程，已经调用了start()方法，线程正在或即将被执行；
Blocked：阻塞状态，运行中的线程，在等待竞争锁时，被阻塞，暂不执行；
Waiting:等待状态，运行中的线程，因为sleep()方法、join()方法等方法的调用，进入等待；
Timed Waiting:计时等待状态，运行中的线程，因为执行sleep(等待毫秒值)join(等待毫秒值)等方法,进入计时等待;
Terminated:终止状态，线程已经终止，因为run()方法已经执行完毕；
当线程启动后,它可以在Runnable、Blocked、Waiting和Timed Waiting这几个状态之间切换,直到最后变成Terminated状态,线程终止。

线程的常见方法

1.线程的插队：join（）方法

join() 方法是 Thread 类的实例方法，可以在一个线程中调用另一个线程的 join() 方法等待其执行完成，并等待线程t 执行完毕后才会被唤醒。此时,并不影响同一时刻处在运行状态的其他线程。
join() 方法是基于协作的线程间等待，调用线程会等待被等待线程执行完毕，期间不会释放锁资源。

		//创建并执行子线程
		MyThread myThread = new MyThread();
		myThread.start();
		//主线程调用myThread子线程的join方法
		//子线程插队，插入到	当前线程main的执行序列前
//		myThread.join();
		myThread.join(500);	
		//join()方法调用后，当子线程执行完毕后，主线程才会再执行
		System.out.println("主线程Main：执行完毕。。。");

join()方法的底层是利用wait()方法实现;

1.2.join（）方法和sleep（）方法的区别

两个方法都可以实现类似"线程等待"的效果,但是仍然有区别;
join()是通过在内部使用synchronized + wait()方法来实现的,所以join()方法调用结束后,会释放锁;
sleep()休眠没有结束前,不会释放锁;

2.线程的中断：interrupt（）方法

interrupt() 方法用于中断正在运行的线程。当调用 interrupt() 方法时，它会将线程的中断状态设置为 “中断”，但并不会直接停止线程的执行。当线程被中断时，它可以选择如何响应中断。线程可以通过检查自己的中断状态并采取适当的行动来响应中断。例如，线程可以选择继续执行，或者可以选择终止自己的执行。
支持线程中断的方法（Thread.sleep() 、join()、wait()等方法）就是在监视线程的中断状态，一旦发现线程的中断状态值被置为“true”，就会抛出线程中断的异常InterruptedException，给WAITING或者TIMED_WAITING等待状态的线程发出一个中断信号，线程检查中断标识，就会以退出WAITING或者TIMED_WAITING等待状态；

public class Test5 {
	public static void main(String[] args) throws InterruptedException {
		System.out.println("main主线程：开始执行");        
        // 创建2个子线程
		Thread t1 = new Thread("线程1") {
			@Override
			public void run() {
				System.out.println(getName() + "：开始执行");
				while(!isInterrupted()) {
					System.out.println(UUID.randomUUID());
				}
				System.out.println(getName() + "：结束执行");
			}
		};
		
		Thread t2 = new Thread("线程2") {
			@Override
			public void run() {
				System.out.println(getName() + "：开始执行");
				while(!isInterrupted()) {
					System.out.println((int)(Math.random()*10000));
				}
				System.out.println(getName() + "：结束执行");
			}
		};
        // 启动子线程
		t1.start();
		t2.start();
        // 主线程休眠10毫秒
		Thread.sleep(10);
        // 10毫秒后，中断子线程1
		t1.interrupt();
        // 子线程1执行结束后，继续执行主线程
		t1.join();
		System.out.println("main主线程：结束执行");
        // 主线程执行结束后，中断子线程2
        // 子线程1的中断，不会影响子线程2
		t2.interrupt();
	}

3.线程的让出：yield（）方法

yield() 方法用于提示线程调度器当前线程愿意放弃对 CPU 的使用，以便其他具有相同优先级的线程有机会执行。调用 yield() 方法会暂停当前正在执行的线程，并将执行机会交给其他具有相同优先级的线程。

	public static void main(String[] args) {
		Thread t1 = new Thread("线程1") {
			@Override
			public void run() {
				for(char c = 'A';c<='Z';c++) {
					System.out.println(c);
				}
			}
		};
		Thread t2 = new Thread("线程2") {
			@Override
			public void run() {
				//Thread.yield();
				for(int i = 1;i<=25;i++) {				
					System.out.println(i);
					Thread.yield();//让当前线程让出cpu
				}
			}
		};
		t1.start();
		t2.start();		
	}

需要注意的是，yield() 方法仅仅是提供了一种提示，实际的线程调度行为由 JVM 的实现和操作系统的调度器来决定。因此，对于不同的 JVM 和操作系统，yield() 方法的行为可能会有所不同。另外，yield() 方法不会释放线程持有的锁。

4.线程的等待：wait（）方法

wait() 方法是 Object 类的实例方法，需要在同步代码块或同步方法中调用，即在持有锁的情况下才能调用。该方法会使当前线程进入等待状态，释放对象锁资源，（会使当前线程让出持有的"this锁",允许其它线程参与竞争CPU执行权(this锁)，而sleep的休眠过程中，当前线程不会让出持有锁！！！）等待其他线程调用相同对象的 notify() 或 notifyAll() 方法来唤醒。

//当前对象.wait(),配合synchronize锁使用
this.wait(1000);

5.线程的唤醒：notify（）方法和notifyAll（）方法

线程的唤醒指的是从等待状态（如调用了wait()方法）中唤醒线程，使其继续执行；
在Java中，线程的唤醒方法有：
notify（）方法：随机唤醒等待的某个线程；
notifyAll（）方法：唤醒全部等待线程；

synchronized (this) {
	while(true) {
		if(ticketNum<=0) {
			//System.out.println(Thread.currentThread().getName()+":没有票了");
			return;
		}else {
			//System.out.println(Thread.currentThread().getName()+"买了一张票，剩余："+ --ticketNum);
		try {
			//让当前线程休息1000秒，模拟延迟
			//休眠过程中，当前线程不会让出“锁”，而是带着锁一起休眠					
//			Thread.sleep(1000);			
			//让当前持有this锁的对象等待，让出锁并等待
			this.wait(1000);
		} catch (InterruptedException e) {
				e.printStackTrace();
		}
	}	
  }
}

等待线程通过调用this.wait()方法进入等待状态，释放锁，并等待唤醒信号，等待线程将继续执行后续的代码。

守护线程

守护线程（Daemon Thread）是一种特殊类型的线程，它的存在并不会阻止 JVM 的退出。当所有的非守护线程都结束时，守护线程会自动终止。
在调用start()方法前,调用setDaemon(true)把该线程标记为守护线程。

Long starTime = System.currentTimeMillis();
Thread t2= new Thread("线程2") {
			@Override
			public void run() {
				try {
					Thread.sleep(5000);		
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				System.out.println("守护线程运行时间："+(System.currentTimeMillis()-starTime));
			}
		};
		t2.setDaemon(true);//设置为守护线程
		t2.start();	
		try {
			Thread.sleep(3000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("主线程运行时间："+(System.currentTimeMillis()-starTime));
	}
}

当主线程结束时，守护线程也会自动终止，即使它还在执行。
需要注意的是，守护线程不能用于执行一些需要完整性保证的任务，比如文件写入操作或数据库事务。因为守护线程在 JVM 退出时会被强制终止，可能导致任务不完整或数据丢失。守护线程通常用于执行一些后台任务或支持性工作，比如垃圾回收器线程。

总结

Java用Thread对象表示一个线程,通过调用start()启动一个新线程;
线程调度由操作系统决定,程序本身无法决定调度顺序
Thread.sleep()可以把当前线程暂停一段时间。
线程的状态有以下6种:New、Runnable、Blocked、Waiting、Timed Waiting、Terminated;
join()方法用于实现线程插队,调用完毕后会释放锁;sleep()方法用于实现线程休眠,调用完毕后不会释放锁。

杨树林_spring

关注

3
点赞
踩
3

收藏

觉得还不错? 一键收藏
1
评论
Java线程基础知识汇总（超详细版）

进程是指在计算机中运行的程序的实例。它是操作系统进行资源分配和调度的基本单位。一个进程可以包含多个线程，每个线程都共享该进程的资源，如内存、文件和打开的网络连接等。每个进程都有自己的地址空间，即独立的内存区域。线程是进程内的执行单元，也是CPU的最小执行单元。一个进程可以包含多个线程，每个线程执行不同的任务。线程共享进程的资源，包括内存、文件和打开的网络连接等。线程之间通过共享内存进行通信，因此比进程间通信更高效。由于线程共享同一进程的地址空间，所以多线程之间的切换更快。
复制链接

扫一扫