并发编程之多线程基础

最新推荐文章于 2024-09-14 18:46:05 发布
最新推荐文章于 2024-09-14 18:46:05 发布
阅读量62 收藏
点赞数
文章标签： 多线程 java 面试 编程语言 大数据
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jiangeeq/article/details/120133451
版权

著作权归作者所有，任何形式的转载都请联系作者获得授权并注明出处。

线程与进程区别

每个正在系统上运行的程序都是一个进程。每个进程包含一到多个线程。线程是一组指令的集合，或者是程序的特殊段，它可以在程序里独立执行。也可以把它理解为代码运行的上下文。所以线程基本上是轻量级的进程，它负责在单个程序里执行多任务。通常由操作系统负责多个线程的调度和执行。

使用线程可以把占据时间长的程序中的任务放到后台去处理，程序的运行速度可能加快，在一些等待的任务实现上如用户输入、文件读写和网络收发数据等，线程就比较有用了。在这种情况下可以释放一些珍贵的资源如内存占用等等。

如果有大量的线程,会影响性能，因为操作系统需要在它们之间切换，更多的线程需要更多的内存空间，线程的中止需要考虑其对程序运行的影响。通常块模型数据是在多个线程间共享的，需要防止线程死锁情况的发生。

总结: 进程是所有线程的集合，每一个线程是进程中的一条执行路径。

多线程应用场景？

答:主要能体现到多线程提高程序效率。
举例: 迅雷多线程下载、数据库连接池、分批发送短信等。

多线程创建方式

第一种继承Thread类 重写run方法

//1. 继承thread类，重写run方法，run方法中，需要线程执行代码
class ThreadDemo01 extends Thread {

	// run方法中，需要线程需要执行代码
	@Override
	public voidrun() {
		for (int i = 0; i < 10; i++) {
			System.out.print("子id:" + this.getId() + ",");
			System.out.print("name:" + getName());
			System.out.println("..i:" + i);
			System.out.println();
		}
	}

}

// 1.什么是线程 线程是一条执行路径，每个线程都互不影响。
// 2.什么是多线程，多线程在一个进程中，有多条不同的执行路径，并行执行。目的为了提高程序效率。
// 3.在一个进程中，一定会主线程。
// 4.如果连线程主线程都没有，怎么执行程序。
// 线程几种分类 用户线程、守护线程
// 主线程 子线程 GC线程
public class Test001 {

	// 交替執行
	public static void main(String[] args) {
		System.out.println("main... 主线程开始...");
		// 1.创建线程
		ThreadDemo01 threadDemo01 = new ThreadDemo01();
		// 2.启动线程
		threadDemo01.start();
		for (int i = 0; i < 10; i++) {
			System.out.println("main..i:" + i);
		}
		System.out.println("main... 主线程结束...");
	}

}

第二种实现Runnable接口,重写run方法

class ThreadDemo02 implements Runnable {

	public voidrun() {
		for (int i = 0; i < 10; i++) {
			System.out.println(" 子 i:" + i);
		}
	}
}

// 1.实现runable接口，重写run方法
public class Thread002 {
	public static void main(String[] args) {
		System.out.println("main... 主线程开始...");
	
		// 创建线程
		ThreadDemo02 threadDemo02 = new ThreadDemo02();
		Thread t1= new Thread(threadDemo02);
		// 启动线程
		t1.start();
		for (int i = 0; i <10; i++) {
			System.out.println("main..i:"+i);
		}
		System.out.println("main... 主线程结束...");
	}

}

第三种使用匿名内部类方式

public class Thread003 {

	public static void main(String[] args) {
		System.out.println("main... 主线程开始...");

		Thread t1 = new Thread(new Runnable() {

			public void run() {
				for (int i = 0; i < 10; i++) {
					System.out.println(" 子 i:" + i);
				}
			}
		});
		t1.start();
		for (int i = 0; i < 10; i++) {
			System.out.println("main..i:" + i);
		}
		System.out.println("main... 主线程结束...");
	}
}

使用继承Thread类还是使用实现Runnable接口好？

使用实现实现Runnable接口好，原因实现了接口还可以继续继承，继承了类不能再继承。

启动线程是使用调用start方法还是run方法？

开始执行线程 注意 开启线程不是调用run方法，而是start方法。

获取线程对象以及名称

常用线程api方法
start()启动线程
currentThread()获取当前线程对象
getID()获取当前线程ID Thread-编号，该编号从0开始
getName()获取当前线程名称
sleep(long mill)休眠线程
Stop()停止线程,
常用线程构造函数
Thread()分配一个新的 Thread 对象
Thread(String name)分配一个新的 Thread对象，具有指定的 name正如其名。
Thread(Runable r)分配一个新的 Thread对象
Thread(Runable r, String name)分配一个新的 Thread对象

守护线程

Java中有两种线程，一种是用户线程，另一种是守护线程。
用户线程是指用户自定义创建的线程，主线程停止，用户线程不会停止
守护线程当进程不存在或主线程停止，守护线程也会被停止。
使用setDaemon(true)方法设置为守护线程

public class Test005 {

	public static void main(String[] args) throws InterruptedException {
		Thread t1 = new Thread(newRunnable() {

			public void run() {
				while (true) {
					try {
						Thread.sleep(1000);

					} catch (Exception e) {
						// TODO: handle exception
					}
					System.out.println("我是子线程(用户线程)");
				}
			}
		});
		// 标识当前方法为守护线程
		t1.setDaemon(true);
		t1.start();
		for (int i = 0; i < 10; i++) {
			Thread.sleep(300);
			System.out.println("main:i:" + i);
		}
		System.out.println("主线程执行完毕...");

	}

}

多线程运行状态

线程从创建、运行到结束总是处于下面五个状态之一：新建状态、就绪状态、运行状态、阻塞状态及死亡状态。

新建状态

当用new操作符创建一个线程时， 例如new Thread(r)，线程还没有开始运行，此时线程处在新建状态。 当一个线程处于新生状态时，程序还没有开始运行线程中的代码

就绪状态

一个新创建的线程并不自动开始运行，要执行线程，必须调用线程的start()方法。当线程对象调用start()方法即启动了线程，start()方法创建线程运行的系统资源，并调度线程运行run()方法。当start()方法返回后，线程就处于就绪状态。

处于就绪状态的线程并不一定立即运行run()方法，线程还必须同其他线程竞争CPU时间，只有获得CPU时间才可以运行线程。因为在单CPU的计算机系统中，不可能同时运行多个线程，一个时刻仅有一个线程处于运行状态。因此此时可能有多个线程处于就绪状态。对多个处于就绪状态的线程是由Java运行时系统的线程调度程序(thread scheduler)来调度的。

运行状态

当线程获得CPU时间后，它才进入运行状态，真正开始执行run()方法.

阻塞状态

线程运行过程中，可能由于各种原因进入阻塞状态:

  1. 线程通过调用sleep方法进入睡眠状态；
  2. 线程调用一个在I/O上被阻塞的操作，即该操作在输入输出操作完成之前不会返回到它的调用者；
  3. 线程试图得到一个锁，而该锁正被其他线程持有；
  4. 线程在等待某个触发条件；

死亡状态

有两个原因会导致线程死亡：

  1. run方法正常退出而自然死亡，
  2. 一个未捕获的异常终止了run方法而使线程猝死。

为了确定线程在当前是否存活着(就是要么是可运行的，要么是被阻塞了)，需要使用isAlive方法。如果是可运行或被阻塞，这个方法返回true； 如果线程仍旧是new状态且不是可运行的， 或者线程死亡了，则返回false.

join()方法作用

当在主线程当中执行到t1.join()方法时，就认为主线程应该把执行权让给t1
例子：创建一个线程，子线程执行完毕后，主线程才能执行。

//join
public class Test006 {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(newRunnable() {
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println("子线程,i:" + i);
                }
            }
        });
        t1.start();
        // 当在主线程当中执行到t1.join()方法时，就认为主线程应该把执行权让给t1
        t1.join();
        for (int i = 0; i < 10; i++) {
            System.out.println("main线程,i:" + i);
        }
    }
}

优先级

现代操作系统基本采用时分的形式调度运行的线程，线程分配得到的时间片的多少决定了线程使用处理器资源的多少，也对应了线程优先级这个概念。在JAVA线程中，通过一个int priority来控制优先级，范围为1-10，其中10最高，默认值为5。下面是源码(基于1.8)中关于priority的一些量和方法。

class PrioritytThread implements Runnable {
    public voidrun() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().toString() + "---i:" + i);
        }
    }
}
public class Test008 {
    public static void main(String[] args) {
        PrioritytThread prioritytThread = new PrioritytThread();
        Thread t1 = new Thread(prioritytThread);
        Thread t2 = new Thread(prioritytThread);
        t1.start();
        // 注意设置了优先级， 不代表每次都一定会被执行。 只是CPU调度会有限分配
        t2.start();
        t1.setPriority(10);
    }
}

Yield方法

Thread.yield()方法的作用：暂停当前正在执行的线程，并执行其他线程。(可能没有效果) yield()让当前正在运行的线程回到可运行状态，以允许具有相同优先级的其他线程获得运行的机会。因此，使用yield()的目的是让具有相同优先级的线程之间能够适当的轮换执行。但是，实际中无法保证yield()达到让步的目的，因为，让步的线程可能被线程调度程序再次选中。结论： 大多数情况下，yield()将导致线程从运行状态转到可运行状态，但有可能没有效果。

实例

现… 在有T1、T2、T3三个线程，你怎样保证T2在T1执行完后执行，T3在T2执行完后执行

class T1 implements Runnable {
    public voidrun() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().toString() + "---i:" + i);
        }
    }
}

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

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

public class JoinThreadDemo02 {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(new T1(), "T1");
        Thread t2 = new Thread(new T2(), "T2");
        Thread t3 = new Thread(new T3(), "T3");
        t1.start();
        t1.join();
        t2.start();
        t2.join();
        t3.start();
        t3.join();
    }
}

git文章所有代码

面试题

  1. 进程与线程的区别？
    答:进程是所有线程的集合，每一个线程是进程中的一条执行路径，线程只是一条执行路径。
  2. 为什么要用多线程？
    答:提高程序效率
  3. 多线程创建方式？
    答:继承Thread或Runnable 接口。
  4. 是继承Thread类好还是实现Runnable接口好？
    答:Runnable接口好，因为实现了接口还可以继续继承。继承Thread类不能再继承。
  5. 你在哪里用到了多线程？
    答:主要能体现到多线程提高程序效率。
    举例:分批发送短信、迅雷多线程下载等。

蒋老湿
关注
并发编程01_多线程基础
Cgg
03-17 369
我的网课的学习笔记总结
【并发编程】线程基础
lxtx
12-17 1143
线程是CPU调度的基本单位，每个线程都是执行一个进程中的某一块代码程序片段。进程多线程是指：一个进程内运行的多个线程，多线程的目的是为了提高CPU的利用率，用以提升程序的执行效率，提高用户体验。串行就是从头到尾一个一个的顺序执行并行就是同时处理这里的并发并不是指三高中的并发问题，是指多线程中的并发概念（CPU调度线程的概念），CPU在极短的时间内，反复切换执行不同的线程，看起来好像在并行。
安琪拉教百里守约学并发编程之多线程基础
安琪拉的博客
04-20 6123
《安琪拉与面试官二三事》系列文章 一个HashMap能跟面试官扯上半个小时 一个synchronized跟面试官扯了半个小时 《安琪拉教鲁班学算法》系列文章 安琪拉教鲁班学算法之动态规划 安琪拉教鲁班学算法之BFS和DFS 安琪拉教鲁班学算法之堆排序 《安琪拉教妲己学分布式》系列文章 安琪拉教妲己分布式限流 《安琪拉教百里守约学并发编程》系列文章 安琪拉教百里守约学并发编程之多线程基础 本文...
Java多线程并发编程技术详解
热门推荐
聚焦于深度解析最新的编程语言特性、框架升级、架构设计、开发工具和最佳实践，涵盖Web前端（如Vue3, React, Angular等）、后端开发（如Node.js, Java, Python等）、移动端开发（iOS, Android原生及跨平台开发）
03-20 2万+
Java多线程并发编程是一项需要深入理解和熟练掌握的技术，只有合理地设计和使用多线程，才能真正发挥其在提升系统性能方面的巨大潜力。随着对Java并发机制及工具类库的深入学习和应用，开发者可以更好地构建高效、稳定的并发系统。
Python中的并发编程：多线程与多进程的比较
一键难忘的博客
03-11 3788
在Python编程领域中，处理并发任务是提高程序性能的关键之一。本文将探讨Python中两种常见的并发编程方式：多线程和多进程，并比较它们的优劣之处。通过代码实例和详细的解析，我们将深入了解这两种方法的适用场景和潜在问题。
Java高级架构师并发编程之多线程专题
06-15
本课程为完整Java高级架构师课程体系，目的在于培养企业急需的高级开发者，课程内容包括Java热门...本章节为并发编程之多线程专题内容，通过老师的讲解，你能掌握多线程的知识和应对企业的面试。 Java架构师课程体系
计算机科学+并发编程+多线程+高性能处理
04-25
它以并发编程和多线程技术为核心，致力于解决高性能处理的需求。无论是开发者、计算机专业学生，还是对高并发多线程技术感兴趣的初学者，都能从中获得丰富的知识和实践经验。 该代码适用于各种需要高并发、多线程...
C#多线程开发之并发编程经典实例.zip
10-13
本资源“C#多线程开发之并发编程经典实例”提供了丰富的实例，旨在帮助C#开发者深入理解并掌握多线程技术。以下是关于C#多线程和并发编程的一些关键知识点： 1. **线程基础**：线程是操作系统分配CPU时间的基本单位...
java并发编程：线程基础
08-09
Java并发编程中的线程基础是理解多线程编程的关键，它涵盖了从线程的创建到管理，再到线程间通信的全过程。多线程编程在处理高性能和高响应性的应用程序时至关重要，因为它允许程序在单个进程中同时执行多个任务，...
Java-网络
最新发布
2301_81543552的博客
09-14 433
Java中的网络编程主要涉及使用Socket类进行网络通信，以及理解各种网络协议。以下是一些关键概念和示例代码，帮助您入门。
上传文件到钉盘流程详解
jspyth的博客
09-14 483
本文详解如何通过钉钉的API实现上传文件到钉盘目录，代码通过JAVA实现。
Java集合：Stack详解
yang_brother的博客
09-10 599
Java 中的Stack类是一个后进先出（LIFO, Last In First Out）的数据结构，它继承自Vector类。尽管Stack是一个可用的类，但它被认为是遗留的，并且在新代码中不推荐使用。通常建议使用Deque或ArrayDeque作为替代。
Java wrapperr打包springboot项目到linux和Windows
欢迎查阅
09-14 786
测试启动就是点击App.bat 就会有信息的输出 installApp就是注册为一个windows上的一个服务。上图文件复制的地方 全部复制过去 保留自己需要的 然后去掉后缀.in。下载：linux的目前免费的 windows 64位的好像收费的。前提： 一定要有Java环境（我使用的是jdk1.8）解压的目录，然后我们新建自己的项目目录java-jsw。前面是你解压的原文件 后边是你自己建的目录路径。步骤和上面的一样 不过复制的文件不一样。下载一个社区版本的应该就够用了。需要注意的点 有Java环境。
C#基础（11）函数重载
a6s686的博客
09-12 811
我们通过这些例子的学习，想毕你一定已经掌握了函数重载的相关内容，我相信你只要稍加练习，便能达到很熟练的程度。不过不管知识点难或者简单，还是那句话，学习路上，戒骄戒躁，脚踏实地。请期待我的下一篇博客！
Spring-di基本使用
2301_76862031的博客
09-09 1409
spirngDi环境搭建，使用流程，set注入，构造注入，对象注入，外部引入注入，内部创建注入，外部引入级联赋值注入，list集合注入，map集合注入，util注入
计算机毕业设计 基于SpringBoot的课程教学平台的设计与实现 Java+SpringBoot+Vue 前后端分离 文档报告 代码讲解 安装调试
weixin_19164791635
09-12 834
本文介绍了一款基于Java、SpringBoot和Vue.js技术的课程教学平台。该平台服务于管理员、学生和教师，提供教学资源管理、课程信息浏览、作业提交与批改等功能，旨在优化教学流程，提升教育质量，促进教育资源的数字化共享，推动教育信息化发展。
Spring AMQP给消息添加头信息
yong472727322的博客
09-10 278
【代码】Spring AMQP给消息添加头信息。
模拟面试后端开发复盘
Java小白的博客 致力分享每一天学到的知识
09-11 1039
一般来说系统的开发和设计思路的话，就是一般现在的项目基本上都是前后端分离架构来实现的，所以在项目的设计时，要分层次结构来划定。前后端分离架构中，前端一般是有专业的前端工程师来写的，因此我们步需要过分的关注前端，可以在github上找到相关的前端项目即可。
安琪拉详解Java并发编程：多线程基础
在Java并发编程中，多线程是核心概念之一，它允许程序同时执行多个任务，从而提高了处理能力。线程是操作系统调度的基本单位，而进程则是拥有独立内存空间和资源的执行实体。在Java中，我们可以通过两种主要方式来...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

蒋老湿

你的鼓励是我创作最大的动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值