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

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

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

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

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

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

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

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

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

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

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

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

通过调用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() {@Overridepublic void run() {for(char i ='A';i<='E';i++) {sb.append(i);}}
};
Thread t2 = new Thread( new Runnable() {		@Overridepublic void run() {for(char i ='a';i<='e';i++) {sb.append(i);}}
});t1.setPriority(8); // 设置数字线程优先级=8t2.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状态,线程终止。

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()是通过在内部使用synchronized + wait()方法来实现的,所以join()方法调用结束后,会释放锁;
3. sleep()休眠没有结束前,不会释放锁;

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") {@Overridepublic void run() {System.out.println(getName() + "：开始执行");while(!isInterrupted()) {System.out.println(UUID.randomUUID());}System.out.println(getName() + "：结束执行");}};Thread t2 = new Thread("线程2") {@Overridepublic 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毫秒后，中断子线程1t1.interrupt();// 子线程1执行结束后，继续执行主线程t1.join();System.out.println("main主线程：结束执行");// 主线程执行结束后，中断子线程2// 子线程1的中断，不会影响子线程2t2.interrupt();}

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

	public static void main(String[] args) {Thread t1 = new Thread("线程1") {@Overridepublic void run() {for(char c = 'A';c<='Z';c++) {System.out.println(c);}}};Thread t2 = new Thread("线程2") {@Overridepublic 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() 方法不会释放线程持有的锁。

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

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

线程的唤醒指的是从等待状态（如调用了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") {@Overridepublic void run() {try {Thread.sleep(5000);		} catch (InterruptedException e) {// TODO Auto-generated catch blocke.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
来源：CSDN
原文：https://blog.csdn.net/HSQdePYZ/article/details/131721454
版权声明：本文为作者原创文章，转载请附上博文链接！
内容解析By：CSDN,CNBLOG博客文章一键转载插件