最全的 Java 线程知识点及案例

最新推荐文章于 2024-09-04 17:28:19 发布
最新推荐文章于 2024-09-04 17:28:19 发布
阅读量1.1w 收藏 88
点赞数 28
分类专栏： # JavaSE Java 文章标签： Java多线程 线程同步 线程通信 线程调度 死锁
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/smile_Running/article/details/86745128
版权
Java 同时被 2 个专栏收录
12 篇文章 1 订阅
订阅专栏
JavaSE
4 篇文章 2 订阅
订阅专栏

博主声明：

转载请在开头附加本文链接及作者信息，并标记为转载。本文由博主 威威喵 原创，请多支持与指教。

本文首发于此   博主：威威喵  |  博客主页：https://blog.csdn.net/smile_running

  • 进程、线程介绍

    多线程编程是我们图形化操作系统的基本要求，比如之前的DOS操作系统，它以命令行的形式来获取用户行为，这种方式比较单一，程序在同一时间内也不会去做其他工作。再比如现在的Windows操作系统、Linux系统也罢，只要是提供丰富的图形化界面的操作系统，程序就不会局限于单一的工作。

    而多线程编程正式为了解决这个问题，如在同一个进程内，比如QQ，我可以一边聊天，一边去下载群里的文件，同时也可以一边上传文件。这就用到了多线程的技术，让程序不局限于单一的工作，利用多余的CPU资源去同时工作，提升用户的体验，这也是图形化系统提升用户体验的最佳实践。

    而进程却和线程有所不同，比如我可以一边写博客（浏览器）、一边听歌（网易云）、一边聊天（QQ、微信）。这里用到了多个不同的程序 ，每个程序都互相独立的工作，在没有进程通信时，大多情况下都不会影响对方工作。我们可以打开任务管理器，可以看到操作系统下的大量进程在同时工作，这就是多进程的概念。

  • 程序、进程、线程概念

  1. 程序(program)，是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。
  2. 进程(process)，是程序的一次执行过程，或是正在运行的一个程序。动态过程：有它自身的产生、存在和消亡的过程。
  3. 线程(thread)，进程可进一步细化为线程，是一个程序内部的一条执行路径。 若一个程序可同一时间执行多个线程，就是支持多线程的

  • 何时应用多线程？

  1. 程序需要同时执行两个或多个任务。
  2. 程序需要实现一些需要等待的任务时，如用户输入、文件读写操作、网络操作、搜索等。
  3. 程序需要一些后台运行的程序时。

  • 实现方式

一、继承Thread类

步骤：

  • 定义子类继承Thread类
  • 子类中重写Thread类中的run方法
  • 创建Thread子类对象，即创建了线程对象 
  • 调用线程对象start方法：启动线程，调用run方法

代码：

public class TestThread {
	public static void main(String[] args) {

		MyThread1 th1 = new MyThread1();
		th1.start();

		/**
		 * 主线程
		 */
		for (int i = 10; i >= 0; i--) {
			System.out.println("Main-" + i);
		}
	}
}

class MyThread1 extends Thread {
	public MyThread1() {
	}

	@Override
	public void run() {
		for (int i = 10; i >= 0; i--) {
			System.out.println("MyThread1-" + i);
		}
	}
}

二、实现Runnable接口

步骤：

  • 定义子类，实现Runnable接口
  • 子类中重写Runnable接口中的run方法
  • 通过Thread类含参构造器创建线程对象
  • 将Runnable接口的子类对象作为实际参数传递给 Thread 类的构造方法中
  • 调用Thread类的start方法：开启线程，调用 Runnable子类接口的run方法

代码：

public class TestThread {
	public static void main(String[] args) {

		MyThread2 th2 = new MyThread2();
		Thread thread = new Thread(th2);
		thread.start();
		/**
		 * 主线程
		 */
		for (int i = 10; i >= 0; i--) {
			System.out.println("Main-" + i);
		}
	}
}

class MyThread2 implements Runnable {
	public void run() {
		for (int i = 10; i >= 0; i--) {
			System.out.println("MyThread2-" + i);
		}
	}
}

实现 Runnable 接口的优点：

  1. Java 是单继承的，用实现接口的方式可以避免单继承的局限问题
  2. 只需 new 一个实现 Runnable 接口的实例，保证了可以共享同一份资源

  • 线程重要内容

一、常用方法

  • void start();  启动线程，并执行对象的run()方法
  • run();  线程在被调度时执行的操作
  • String getName();  返回线程的名称
  • void setName(String name);  设置该线程名称
  • static currentThread();  返回当前线程

修改如上代码：

public class TestThread {
	public static void main(String[] args) {
		/**
		 * 继承 Thread 的方式
		 */
		MyThread1 th1 = new MyThread1();
		th1.setName("==th1==");
		th1.start();

		/**
		 * 实现 Runnable 接口的方式
		 */
		MyThread2 th2 = new MyThread2();
		Thread thread = new Thread(th2);
		thread.setName("==th2==");
		thread.start();
		/**
		 * 主线程
		 */
		for (int i = 10; i >= 0; i--) {
			System.out.println(Thread.currentThread().getName() + ":" + i);
		}
	}
}

class MyThread1 extends Thread {
	public MyThread1() {
	}

	@Override
	public void run() {
		for (int i = 10; i >= 0; i--) {
			System.out.println(Thread.currentThread().getName() + ":" + i);
		}
	}
}

class MyThread2 implements Runnable {
	public void run() {
		for (int i = 10; i >= 0; i--) {
			System.out.println(Thread.currentThread().getName() + ":" + i);
		}
	}
}

二、线程调度

    Java对线程的调度方法：

  1. 对于同优先级线程，组成一个队列，以先进先出的方式抢占CPU资源
  2. 对于高优先级的线程，赋予优先的抢占式资源（但是也不是绝对的能够抢到）

1、设置线程优先级

    线程的优先级分为三个等级，分别为 MAX_PRIORITY（10）;     MIN _PRIORITY （1）;   NORM_PRIORITY （5）;通过：

  1. getPriority() ：返回线程优先值，默认为5
  2. setPriority(int newPriority) ：改变线程的优先级，线程创建时继承父线程的优先级

2、yieid()、join()、sleep()

  1. yield()：线程让步，暂停当前正在执行的线程，把执行机会让给优先级相同或更高的线程。若队列中没有同优先级的线程，忽略此方法。
  2. join() ：当某个程序执行流中调用其他线程的 join() 方法时，调用线程将被阻塞，直到 join() 方法加入的 join 线程执行完为止，低优先级的线程也可以获得执行 。
  3. sleep(long millis)(毫秒) ： 令当前活动线程在指定时间段内放弃对CPU控制,使其他线程有机会被执行,时间到后重排队。
  4. isAlive()：判断线程是否还活着

例子：实现有三个人同时去银行取款机取钱，这三个同时操作。设银行共有10000元，第一人取1500，第二人取2000，第三人取3000，结算银行剩余多少钱？

    这个问题比较简单，但是存在一个bug，线程抢夺cpu资源的问题。如果第一个人在取的时候，恰巧cpu资源权被第二个人抢了，那就造成问题。

public class TestThread {
	public static void main(String[] args) {
		Bank bank = new Bank();

		bank.getMoney(1500);
		Thread person1 = new Thread(bank);
		person1.setName("==person1==");
		person1.start();
		try {
			person1.join();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}

		bank.getMoney(2000);
		Thread person2 = new Thread(bank);
		person2.setName("==person2==");
		person2.start();
		try {
			person2.join();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		
		bank.getMoney(3000);
		Thread person3 = new Thread(bank);
		person3.setName("==person3==");
		person3.start();
		try {
			person3.join();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}

class Bank implements Runnable {

	int totalMoney = 10000;
	int money;// 要取出的钱

	public void getMoney(int money) {
		this.money = money;
	}

	public void run() {
		String name = Thread.currentThread().getName();
		System.out.println(name + "取出：" + money);
		int remainMoney = totalMoney - money;
		totalMoney = remainMoney;
		System.out.println("银行剩余:" + remainMoney);
	}
}
  •     正常执行结果等于3500：

    如果注释上面代码中线程的 join() 方法，意味着三个人对cpu的获取权一样大，比如第一个人取到一半，执行权被第二个人给抢了，这就会导致金钱出现异常。

  •     注释全部 join() 后执行结果：

三、线程生命周期

四、线程同步（synchronized）

    线程同步指的是同一个线程来操作同一份资源，那不同步就有线程安全问题了。在线程并发时，如果不同的多个线程同时操作同一封资源的话，那将会造成数据紊乱。

    举个实际中的例子，我在乘坐高铁时想上厕所，这时厕所显示绿色，发现厕所没人用，我就进去了，却不小心门没有关紧。这时又来了一位想上厕所的人，由于门没关好，厕所上面的灯是绿色的，所以这位后面来的人就开门进来了，这就导致厕所紊乱了。

    用这个例子反证线程的执行过程，简直一模一样。这个厕所，就如线程处理的同一份资源。多个人就对应多个线程，在同时处理一份资源时，问题就来了。

    互斥锁（synchronized），这是一个关键字。作用在同一份资源上时，就是相当于厕所上面的指示器的作用，给这个资源加上一把锁，你其他线程不许进来，等我处理结束后再说。

看一个例子：

    一家电影院有三个售票窗口，这部电影共有30个座位（30张票）。如果三个窗口同时卖票，则该如何操作？

public class TestThread {
	public static void main(String[] args) {
		Cinema cinema = new Cinema();

		Thread window1 = new Thread(cinema);
		window1.setName("==窗口1==");
		window1.start();

		Thread window2 = new Thread(cinema);
		window2.setName("==窗口2==");
		window2.start();

		Thread window3 = new Thread(cinema);
		window3.setName("==窗口3==");
		window3.start();
	}
}

class Cinema implements Runnable {

	int ticket = 30;

	public void run() {
		String name = Thread.currentThread().getName();
		while (true) {
			if (ticket > 0) {
				try {
					Thread.currentThread().sleep(50);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				System.out.println(name + "售出" + ticket-- + "号座位");
			}
		}
	}
}

    从打印结果可以看出，不仅出现了重复座位，而且还出现了 0 号座位，存在极大的bug。出现bug的原因：多个线程参与同一个数据的操作，如上代码中，多个线程同时卖30张票，却没有给操作同一个资源加锁，就会出现这种bug。

1、同步代码块

    修改 run()，添加 synchronized（Object obj） 关键字。这里一般传入 this ，this 即 Cinema 类的对象。

class Cinema implements Runnable {

	int ticket = 30;

	public void run() {
		while (true) {
			synchronized (this) {
				if (ticket > 0) {
					try {
						Thread.currentThread().sleep(50);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					System.out.println(Thread.currentThread().getName() + "售出" + ticket-- + "号座位");
				}else {
					break;
				}
			}
		}
	}
}

2、同步方法

class Cinema implements Runnable {

	int ticket = 30;
	boolean flag = true;

	public void run() {
		while (flag) {
			sell();
		}
	}

	public synchronized void sell() {
		if (ticket > 0) {
			try {
				Thread.currentThread().sleep(50);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName() + "售出" + ticket-- + "号座位");
			flag = true;
		} else {
			flag = false;
		}
	}
}

    同步代码块、同步方法都可以决解线程安全问题。其实，线程安全的单利模式也是可以的，只要保证操作资源的线程同一时间内是唯一的就可以了。

    结果正常：

    注意：线程执行同步代码块或同步方法时，程序调用Thread.sleep()、Thread.yield()方法暂停当前线程的执行，此时并不会释放锁。

五、死锁

    说到调用 sleep() 方法不会释放锁，那么如果多个线程同时操作对方的资源，谁都不愿意释放的话，那程序就会停止，就会造成死锁的情况了。死锁就是不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁。

    举个实际例子：有一天，老王和老张在工地里吃饭，恰巧剩下最后一双筷子。老王拿了一根，老张拿了一根（就当这俩有毛病吧）。于是老张在等待老王放弃筷子，那么老王也想让老张先放弃。这时，他们俩就抢了起来啊，然后咔嚓一声，其中一根断了（意味着程序bug），那么这俩货就这样僵持住了，谁也吃不了。

死锁代码：

public class TestDeadlock implements Runnable {

	Zhang zhang = new Zhang();
	Wang wang = new Wang();

	public void init() {
		zhang.waitting(wang);
	}

	public static void main(String[] args) {
		System.out.println("老张、老王各有一根筷子");
		TestDeadlock dl = new TestDeadlock();
		new Thread(dl).start();
		dl.init();
	}

	@Override
	public void run() {
		wang.waitting(zhang);
	}
}

class Zhang {

	public synchronized void waitting(Wang wang) {
		try {
			Thread.currentThread().sleep(200);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		wang.eat();
	}

	public synchronized void eat() {
		System.out.println("老张想吃饭，等待老王给筷子");
	}
}

class Wang {
	public synchronized void waitting(Zhang zhang) {
		zhang.eat();
	}

	public synchronized void eat() {
		System.out.println("老王想吃饭，等待老张给筷子");
	}
}

   死锁的原因就是不同的线程分别占了对方也需要的资源，这时谁也不肯退让，导致程序停止。我们不可能去专门编写死锁，但出现死锁时就要我们去解救。解决方法：专门的算法、原则。或者尽量减少同步资源的定义。

六、线程通信

    线程的通信，通过wait() 与 notify() 和 notifyAll()三个方法实现。所谓通信，就是某一个线程被wait()之后，其他线程通过notify()和notifyAll()将其唤醒。wait()不同于sleep()，这一点很重要。sleep()方法可以通过自定义的一段时间后自动唤醒，而wait()只能被notify的时候才可以苏醒，否则线程将进入停滞状态。

  1. wait()：令当前线程挂起并放弃CPU、同步资源，使别的线程可访问并修改共享资源，当前线程排队等候再次对资源的访问
  2. notify()：唤醒正在排队等待同步资源的线程中优先级最高者结束等待
  3. notifyAll ()：唤醒正在排队等待资源的所有线程结束等待

例子：打印整数，实现单双号交替

public class TestThread3 {

	public static void main(String[] args) {

		MyThread myThread = new MyThread();

		Thread th1 = new Thread(myThread);
		th1.setName("==单数==");
		th1.start();

		Thread th2 = new Thread(myThread);
		th2.setName("==双数==");
		th2.start();
	}

}

class MyThread implements Runnable {
	int count = 21;

	public void run() {
		while (true) {
			synchronized (this) {
				notify();
				if (count > 0) {
					System.out.println(Thread.currentThread().getName() + count--);
				} else {
					break;
				}
				
				try {
					wait();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}
	}
}

    到此为止，线程的几个内容已经基本讲完了。掌握这些线程的知识点，可以开发出更加高效的软件，多线程编程也是能写出更高效软件的一种手段。

威威貓
关注
专栏目录
Java基础核心技术：多线程(day16-day17)
05-11
本套Java视频完全针对初级学员，课堂实录，自发布以来，好评如潮！Java视频中注重与学生互动，讲授幽默诙谐、细致入微，覆盖Java基础所有核心知识点，同类Java视频中也是代码量大、案例多、实战性强的。同时，本Java视频教程注重技术原理剖析，深入JDK源码，辅以代码实战贯穿始终，用实践驱动理论，并辅以必要的代码练习。
【Java】多线程、线程同步、线程通信、线程调度与死锁
weixin_34220834的博客
02-02 194
目 录（本篇字数：3817） 进程、线程介绍 程序、进程、线程概念 何时应用多线程？ 实现方式 一、继承Thread类 二、实现Runnable接口 线程重要内容 一、常用方法 二、线程调度 1、设置线程优先级 2、yieid()、join()、sleep() 三、线程生命周期 四、线程同步（synchronized） 1、同步代...
java学习笔记-线程(基础)-韩顺平
最新发布
2301_79070677的博客
09-04 1375
java语言中，引入了对象互斥锁的概念，来保证共享数据操作的完整性。每个对象都对应一个可称为"互斥锁"的标记，这个标记用来保证在任意时刻，只能有一个线程访问该对象。关键字synchronized来与对象的互斥锁联系。当某个对象用synchronized修饰时，表明该对象在任意时刻只能由一个线程访问同步的局限性：导致程序的执行效率要降低同步方法(非静态的)的锁可以是this，也可以是其他对象(要求是同一个对象)同步方法(静态的)的锁为当前类本身​​​/**
JAVA线程
互联网底层民工的博客
06-26 9852
虽然我们可以理解同步代码块和同步方法的锁对象问题，但是我们并没有直接看到在哪里加上了锁，在哪里释放了锁，为了更清晰的表达如何加锁和释放锁，JDK5以后提供了一个新的锁对象Lock，Lock是接口不能直接实例化，这里采用它的实现类ReentrantLock来实例化。
java 线程详解
muranfei的博客
07-02 1万+
一、线程的基本概念 一个线程就是在进程中的一个单一的顺序控制流. 而单个进程可以拥有多个并发执行的任务，每个任务都好像有自己的CPU一样，而其底层的机制就是切分CPU的时间，也就是CPU将轮流给每个任务分配其占用时间。 每个任务都觉得自己在一直占用CPU，而事实上是将CPU时间划分成片段分配给所有的任务。 在多个CPU的环境下，多线程的运作，可以极大的提供程序的运行速度，这就是线程存在的意...
Java线程系列详解
wang_yong_hui_1234的博客
04-15 5222
1）volatile本质是在告诉jvm当前变量在寄存器中的值是不确定的，需要从主存中读取，synchronized则是锁定当前变量，只有当前线程可以访问该变量，其他线程被阻塞住。2）volatile仅能使用在变量级别，synchronized则可以使用在变量，方法。3）volatile仅能实现变量的修改可见性，而synchronized则可以保证变量的修改可见性和原子性。4）volatile不会造成线程的阻塞，而synchronized可能会造成线程的阻塞。
互联网公司Java面试题及核心知识点
06-26
无论你是初学者还是有一定经验的开发者，本资源都能帮助你系统地学习和掌握Java并发编程的相关知识和技术。 使用场景及目标：本资源主要面向开发多线程应用和高并发应用的场景。无论你是要开发高性能的服务器端应用...
Java实现的两个线程同时运行案例
08-25
通过本文，我们可以学习到如何使用Java实现多线程编程，如何创建和启动线程，如何使用Runnable接口来实现线程的任务等知识点。 学习Java多线程编程需要掌握的知识点包括： 1. Java多线程编程的基本概念 2. 如何...
java多线程经典案例
01-15
本案例将深入探讨Java多线程中的关键知识点，包括线程同步、线程通信和线程阻塞。 线程同步是为了防止多个线程同时访问共享资源，导致数据不一致。Java提供了多种同步机制，如synchronized关键字、Lock接口...
Java多线程程序案例
12-06
根据给定文件的信息，我们可以提炼出以下关于Java多线程程序设计的知识点： ### Java多线程基础 在Java中，多线程是通过`Thread`类或实现`Runnable`接口来实现的。多线程可以提高程序的执行效率，尤其是在处理CPU...
Java线程组操作实例分析
08-25
本文主要介绍了Java线程组操作的相关知识点，包括ThreadGroup类的作用、Thread类与ThreadGroup类的关系、ThreadGroup类的主要方法等。通过实战示例，演示了如何使用ThreadGroup类创建线程组和管理线程。Java开发者...
Java 线程 基础知识总结
Zhangguohao666的博客
07-27 6332
文章目录线程基础生产消费者模型，synchronizedjoin方法+死锁（哲学家进餐问题）join和锁死锁有趣的Timer类Timer多线程的一个运行实例 初步认识下线程，线程怎么去实现（通过继承Thread或者实现Runnable接口） 线程基础 很不严谨的说，线程是什么？线程就是为了让很多个东东并发执行，大大的提高程序执行的效率啊 三个非常重要的概念： 程序：一组写好了的静态代码块（就我...
编程必备：JAVA多线程详解
拾一二的博客
06-14 8616
多线程已经成为一种常见的编程模式，广泛应用于各种不同类型的应用程序中。本篇博客文章中，我们将会探讨多线程编程的相关知识和技巧。通过代码示例和实际应用案例来深入了解多线程的具体实现和应用方法，帮助更好地掌握多线程编程技术，提高程序效率和性能。后期随学习深入还会补充修改。以上就是我对多线程的个人简介，后续会不断完善更新，与大家共勉。
JAVA多线程详解（超详细）
m0_74823434的博客
10-10 1万+
程序：开发写的代码称之为程序。程序就是一堆代码，一组数据和指令集，是一个静态的概念。进程(Process)：将程序运行起来，我们称之为进程。进程是执行程序的一次执行过程，它是动态的概念。进程存在生命周期，也就是说程序随着程序的终止而销毁。进程之间是通过TCP/IP端口实现交互的。线程(Thread)：线程是进程中的实际运作的单位，是进程的一条流水线，是程序的实际执行者，是最小的执行单位。通常在一个进程中可以包含若干个线程，当然一个进程中至少有一个线程。线程是CPU调度和执行的最小单位。注意。
java多线程（超详细）
zdl66的博客
08-14 10万+
进程就是正在运行中的程序（进程是驻留在内存中的）是系统执行资源分配和调度的独立单位每一进程都有属于自己的存储空间和系统资源注意：进程A和进程B的内存独立不共享。
【JAVA】线程详解
weixin_37559642的博客
08-15 3059
线程详解
Java多线程超详解
热门推荐
weixin_44797490的博客
06-11 14万+
引言 随着计算机的配置越来越高，我们需要将进程进一步优化，细分为线程，充分提高图形化界面的多线程的开发。这就要求对线程的掌握很彻底。 那么话不多说，今天本帅将记录自己线程的学习。 线程的相关API //获取当前线程的名字 Thread.currentThread().getName() 1.start():1.启动当前线程2.调用线程中的run方法 2.run():通常需要重写Thread类中的此...
Java创建线程的七种方法，全网最全面总结~
CYK_byte的博客
02-03 2万+
属于基础的面试问题，一定要能够回答全哦~
一篇搞懂Java多线程（全网最细）
让优秀成为一种习惯！
07-22 1万+
Java多线程是一种强大而有趣的编程概念。它允许程序同时执行多个任务，就像一个宏大的交响乐团。每个线程都是一个独立的执行路径，有自己的速度和优先级。那么，我们期待多线程能给我们带来什么呢？
Java线程在海底世界案例中的应用
资源摘要信息: "本案例通过Java Swing构建了一个模拟海底世界的图形用户界面（GUI），在此基础上利用Java线程实现了海底世界的动态效果。本案例涵盖了GUI编程、事件处理以及多线程编程的知识点，尤其适用于初学者和...
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值