Java_从入门到JavaEE_20

最新推荐文章于 2024-07-12 16:26:30 发布
最新推荐文章于 2024-07-12 16:26:30 发布
阅读量979 收藏 5
点赞数 32
文章标签： java java-ee 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lv785/article/details/139073309
版权

多线程

一、什么是进程

进程是系统进行资源分配和调用的独立单元，每一个进程都有它的独立内存空间和系统资源。

二、单进程操作系统和多进程操作系统的区别

单进程操作系统：dos（一瞬间只能执行一个任务）

多进程单用户操作系统：Windows（一瞬间只能执行多个任务）

多进程多用户操作系统：Linux（一瞬间只能执行多个任务）

三、现在的多核CPU是否可以让系统在同一个时刻可以执行多个任务吗？

理论上是可以的

四、什么是线程，理解线程和进程的关系

什么是线程？

线程是进程里面的一条执行路径，每个线程同享进程里面的内存空间和系统资源

一个进程 可以有 多个线程：各个线程都有不同的分工

理解线程和进程的关系

进程 与 进程 之间的关系：进程之间的内存空间和系统资源是独立的

同一个进程里的多条线程 ：线程之间的内存空间和系统资源是共享的

进程里：可以有一条或一条以上的线程

进程里只有一条线程的情况下，这条线程就叫做主线程

进程里有多条线程的情况下，只有一条线程叫做主线程

Ps：线程是在进程里的，他们是包含关系

五、我们应用的软件有哪些是多线程的应用？

都是

六、Java中，如何来编写多线程的应用程序？有哪些方法？

1.线程类

创建MyThread类，继承Thread，重写run方法

public class Test {
	
	public static void main(String[] args) {
		
		//创建线程的对象
		MyThread t = new MyThread();
		//启动线程
		t.start();
	}
}
//线程类
class MyThread extends Thread{
	
	//当前线程抢到cpu资源后，就会执行run方法
	@Override
	public void run() {
		System.out.println("当前线程抢到资源了");
	}
}

2.任务类

创建Task类，实现Runnable接口中的run方法

public class Test {
	
	public static void main(String[] args) {
		
		Thread t = new Thread(new Task());
		t.start();
	}
}
//任务类
class Task implements Runnable{

	//当前线程抢到cpu资源后，就会执行run方法
	@Override
	public void run() {
		System.out.println("抢到资源了");
	}
}

3.带返回值的任务类

4.线程池

七、感受多线程之间争抢资源的场景

需求：编写一个多线程的应用程序，主线程打印1-100之间的数字，子线程打印200-300之间的数字，观察其输出的结果，体会多线程互相争抢资源的场景

public class Test {
	public static void main(String[] args) {
		MyThread t = new MyThread();
		t.start();
		for (int i = 1; i <= 100; i++) {
			System.out.println("主线程：" + i);
		}
	}
}
public class MyThread extends Thread{

	@Override
	public void run() {
		
		for (int i = 200; i <= 300; i++) {
			System.out.println("子线程：" + i);
		}
		
	}
}

截图：

在这里插入图片描述

八、小结

进程 与 进程 的关系：独享内存空间和系统资源

线程 与 进程 的关系：有一个进程中至少包含一个线程

线程 与 线程 的关系：在同一个进程里，多个线程共享内存空间和系统资源

一个进程中包含多个线程，只有一个主线程

当我们编写一个单纯的main方法时，此时该程序是否为单线程的？

垃圾回收器是一个后台线程

九、线程的优先级别

需求：在主线程中创3个子线程，并且设置不同优先级，观察其优先级对线程执行结果的”影响”。

a.setPriority(Thread.MAX_PRIORITY);//10
b.setPriority(Thread.NORM_PRIORITY);//5
c.setPriority(Thread.MIN_PRIORITY);//1

优先级别：1~10（数字越大优先级越高）
线程的优先级只能影响抢到CPU资源的概率，不是决定性的！

十、给线程自定义名称

  1. 写getThreadName/setThreadName
  2. 调用父类的一个参数的构造方法和getName
  3. Thread.currentThread().getName()

十一、让线程休眠

需求：编写一个抽取学员回答问题的程序，要求倒数三秒后输出被抽中的学员姓名

import java.util.Random;
public class Test {
	public static void main(String[] args) throws InterruptedException {		
		String[] names = {"aaa","bbb","ccc","ddd","eee"};		
		Random ran = new Random();
		int index = ran.nextInt(names.length);		
		for (int i = 3; i >= 1;i--) {
			System.out.println(i);			
			Thread.sleep(1000);
		}		
		System.out.println(names[index]);
	}
}

Thread.sleep(1000);

此方法为静态方法，写在哪个线程中，哪个线程就休眠

十二、线程的礼让

需求：创建两个线程A,B，分别各打印1-100的数字，其中B一个线程，每打印一次，就礼让一次，观察实验结果

public class Test {
	public static void main(String[] args) {	
		A a = new A();
		B b = new B();	
		a.start();
		b.start();
	}
}
public class A extends Thread{
	
	@Override
	public void run() {
		for (int i = 1; i <= 100; i++) {
			System.out.println("A：" + i);
		}
	}
}
public class B extends Thread{
	
	@Override
	public void run() {
		for (int i = 1; i <= 100; i++) {
			System.out.println("B：" + i);			
			Thread.yield();
		}
	}
}

Thread.yield();

此方法为静态方法，此方法写在哪个线程中，哪个线程就礼让

所谓的礼让是指当前线程退出CPU资源，并转到就绪状态，接着再抢

十三、线程的合并

需求：主线程和子线程各打印200次，从1开始每次增加1，当主线程打印到10之后，让子线程先打印完再打印主线程

public class Test01 {
	public static void main(String[] args) throws InterruptedException {		
		MyThread t = new MyThread();
		t.start();		
		for (int i = 1; i <= 200; i++) {
			System.out.println("主线程：" + i);
			if(i == 10){
				
				t.join();
			}
		}
	}
}
public class MyThread extends Thread{

	@Override
	public void run() {
		for (int i = 1; i <= 200; i++) {
			System.out.println("子线程：" + i);
		}
	}
}

t.join(); 合并方法

十四、线程的销毁

关闭线程

t.setFlag(false);
t.interrupt();//改变线程存活状态

public class Test {	
	public static void main(String[] args) throws InterruptedException {		
		MyThread t = new MyThread();
		t.start();		
		Thread.sleep(3000);	
		//t.interrupt();
        t.setFlag(false);		
	}	
}
public class MyThread extends Thread{	
	private boolean flag = true;
	@Override
	public void run() {
		while(flag){
			System.out.println("111");
			System.out.println("222");
			System.out.println("333");
			System.out.println("444");
		}
	}
	public void setFlag(boolean flag) {
		this.flag = flag;
	}
}

十五、守护线程

守护线程 默默守护着前台线程，当所有的前台线程都消亡后，守护线程会自动消亡

注意：垃圾回收器就是守护线程

t.setDaemon(true);

十六、线程局部变量（实现线程范围内的共享变量）

  1. 需求：共享单个数据
import java.util.concurrent.ConcurrentHashMap;
public class Test {
	public static ConcurrentHashMap<Thread, Integer> map  = new ConcurrentHashMap<>();	
	public static void main(String[] args) {		
		new Thread(new  Runnable() {			
			@Override
			public void run() {
				int i = 10;				
				map.put(Thread.currentThread(), i);			
				A a = new A();
				B b = new B();
				a.println();//10
				b.println();//10
			}
		}, "线程1").start();
			
		new Thread(new Runnable() {
			@Override
			public void run() {
				int i = 20;			
				map.put(Thread.currentThread(), i);			
				A a = new A();
				B b = new B();
				a.println();//20
				b.println();//20
			}
		}, "线程2").start();
	}
}
public class A {
	public void println(){		
		Thread thread = Thread.currentThread();
		Integer value = Test01.map.get(thread);
		System.out.println(thread.getName() + "里的A类对象获取了数据：" + value);		
	}
}
public class B {
	public void println(){		
		Thread thread = Thread.currentThread();
		Integer value = Test01.map.get(thread);
		System.out.println(thread.getName() + "里的B类对象获取了数据：" + value);
	}
}
  1. 需求：共享多个数据
import java.util.concurrent.ConcurrentHashMap;
public class Test01 {
	public static ConcurrentHashMap<Thread, Data> map  = new ConcurrentHashMap<>();	
	public static void main(String[] args) {		
		new Thread(new  Runnable() {			
			@Override
			public void run() {
				int i = 10;
				String str = "张三";
				Data data = new Data(i, str);
				
				map.put(Thread.currentThread(), data);
				
				A a = new A();
				B b = new B();
				a.println();//10
				b.println();//10
			}
		}, "线程1").start();
			
		new Thread(new Runnable() {
			@Override
			public void run() {
				int i = 20;
				String str = "李四";
				Data data = new Data(i, str);				
				map.put(Thread.currentThread(), data);			
				A a = new A();
				B b = new B();
				a.println();//20
				b.println();//20
			}
		}, "线程2").start();
	}
}
//数据容器类
public class Data {
	private int i;
	private String str;	
	public Data(int i, String str) {
		this.i = i;
		this.str = str;
	}
	public int getI() {
		return i;
	}
	public void setI(int i) {
		this.i = i;
	}
	public String getStr() {
		return str;
	}
	public void setStr(String str) {
		this.str = str;
	}
	@Override
	public String toString() {
		return i + " -- " + str;
	}
}
public class A {
	public void println(){		
		Thread thread = Thread.currentThread();
		Integer value = Test01.map.get(thread);
		System.out.println(thread.getName() + "里的A类对象获取了数据：" + value);		
	}
}
public class B {
	public void println(){		
		Thread thread = Thread.currentThread();
		Integer value = Test01.map.get(thread);
		System.out.println(thread.getName() + "里的B类对象获取了数据：" + value);
	}
}

十七、线程的生命周期

1、新建状态

i. 在程序中用构造方法创建了一个线程对象后，新的线程对象便处于新建状态，此时，它已经有了相应的内存空间和其它资源，但还处于不可运行状态。新建一个线程对象可采用线程构造方法来实现。

ii. 例如：Thread thread=new Thread();

2、 就绪状态

i. 新建线程对象后，调用该线程的start()方法就可以启动线程。当线程启动时，线程进入就绪状态。此时，线程将进入线程队列排队，等待CPU调用，这表明它已经具备了运行条件。

3、运行状态

i. 当就绪状态的线程被调用并获得处理器资源时，线程就进入了运行状态。此时，自动调用该线程对象的run()方法。run()方法定义了该线程的操作和功能。

4、 阻塞状态

i. 一个正在执行的线程在某些特殊情况下，如被人为挂起，将让出CPU并暂时中止自己的执行，进入阻塞状态。在可执行状态下，如果调用sleep(2000)、wait()等方法，线程都将进入阻塞状态。阻塞时，线程不能进入排队队列，只有当引起阻塞的原因被消除后，线程才可以转入就绪状态。

5、死亡状态

i. 线程调用stop()方法时或run()方法执行结束后，线程即处于死亡状态。处于死亡状态的线程不具有继续运行的能力。

在这里插入图片描述

静风残云
关注
  • 32
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
从java走向javaEE
11-23
总而言之，《从Java走向JavaEE》是一本适合初学者的入门书籍，它将引导读者从简单的Java编程逐渐过渡到复杂的JavaEE企业级应用开发。通过实践书中的代码示例，读者可以巩固理论知识，提高实际开发能力。然而，要想在...
Java 从入门到精通全程笔记(JavaSE+JavaEE :史上最全笔记）
11-28
JavaSE+JavaEE企业级开发 全程笔记免费下载，内容详尽，doc文档,共173页,六号字体，双栏排版。 *、Java 基础， *、web， *、数据库（Mysql Oracle jdbc Hibernate hql/sql）， *、JSP， *、Ajax *、Struts， *、...
Java_从入门到JavaEE_11
lv785的博客
05-08 1401
接口不可以new对象，接口是特殊的抽象类，但是本质还是抽象类，抽象类是不可以new对象的，接口也是不能new对象，new出来的匿名类内部类的对象。接口里面的方法不一定都是抽象的，JDK1.8之前：接口中只能有静态常量和抽象方法，JDK1.8开始：接口中可以使用默认方法和静态方法。如果父类是抽象类，子类不一定实现父类的抽象方法，子类如果是抽象类，可以不实现父类的抽象方法。理解：实现类对象指向接口的引用（接口的引用中存储的是实现类对象在堆中开辟的地址）一个接口不可以实现多个接口，因为接口与接口的关系是多继承。
Java_从入门到JavaEE_15
lv785的博客
05-14 1166
虽然使用其它的 Map 实现（如HashMap）也能完成枚举类型实例到值得映射，但是使用 EnumMap 会更加高效，因为它只能接收同一枚举类型的实例作为键值，并且由于枚举类型实例的数量相对固定并且有限，所以 EnumMap 使用数组来存放与枚举类型对应的值。尽管枚举看起来像是一种新的数据类型，实际上，枚举就是一种受限制的类，并且具有自己的方法。（枚举类编译时，没有把常量值编译到代码中，即使常量值发生改变，也不会影响引用常量的类 ）优点：这种枚举通过枚举嵌套枚举的方式，将枚举常量分类处理。
Java_从入门到JavaEE_14
lv785的博客
05-13 942
含义：用来描述或者匹配一系列符合某个语句规则的字符串案例：把一个字符串中带电话号码替换成111****1234总结：利用正则表达式对字符串进行替换，校验，分割，爬数据。常用表达式：见正则表达式常用表达式。
Java_从入门到JavaEE_19
lv785的博客
05-18 837
在定义一个方法的时候可以使用throws关键字声明，使用throws声明的方法表示此方法不处理异常，而交给方法的调用出进行处理。JDK新特性，一个catch代码可以可以声明多个能处理的特定异常的类型，多个类型之间用”|”隔开。写catch代码时，先捕获的异常的范围不能大于后捕获的异常的范围。定义一个方法的时候，通过这种方式来告知调用方，我这个方法有可能会发生异常的。注意：此时抛出的是异常类型，并且抛出的异常类型是紧跟在方法名之后。当异常发生时，程序会中止当前的流程去执行相应的catch代码段。
Java_从入门到JavaEE_18
lv785的博客
05-17 312
JDK1.8版本的HashMap，数据结构是一维数组+单向链表+红黑树，获取hash值使用高16位^低16位，尾插法。多个key的hash值一样，意味着下标也是一样，在底层就会将多个key存储在一个单向链表里，效率极低。JDK1.7版本的HashMap，数据结构是一维数组+单向链表，获取hash值使用位移计算，头插法。因为不用的字符串的hash值有可能相同，会造成hash碰撞，所以hash种子数就应运而生了~~计算hash值是 数组长度-1 & key的hash值，2的幂长度会导致下标结果分布更加散列。
Java_从入门到JavaEE_04-1
lv785的博客
04-25 240
含义：具有特殊意义的字符本身。
Java_从入门到JavaEE_12+13
lv785的博客
05-10 1417
深入：现在的需求要存储10000个长度的数据，不要使用new StringBuilder()的方式，因为使用无参构造，底层会创建16长度的容器，存储10000个数据需要多次扩容，效率极低，直接使用new StringBuilder(10000)的方式，一步到位。​ Java为纯面向对象语言（万物皆对象），但是8种基本数据类型不能new对象，破坏了Java为纯面向对象语言的特征，所以Java又为8种基本你数据类型分别匹配了对应的类，这种类叫做包装类/封装类。案例：创建成员内部类的对象，并调用方法。
Java_从入门到JavaEE_08
lv785的博客
05-01 973
Eclipse工具简绍Eclipse 是著名的跨平台的自由集成开发环境（IDE）。最初主要用来 Java 语言开发，但是目前亦有人通过插件使其作为其他计算机语言比如 C++ 和 Python 的开发工具。下载与安装下载：安装：因为Eclipse为绿色软件，直接解压缩运行.exe就行。打开问题：下载包一般不会出问题，Eclipse打不开一般有两方面的问题：电脑中JDK设置的环境变量有问题，Eclipse无法正确找到。下载的Eclipse版本，和电脑安装JDK版本不兼容。
Java_从入门到JavaEE_01
lv785的博客
04-24 194
​ 接受来自客户端的请求、处理业务、操作数据库、利用相应向客户端换回数据的技术叫做JavaEE.​ 1、JDK：Java开发工具包​ 2、JRE：Java运行环境。
Java_从入门到JavaEE_16
lv785的博客
05-15 1338
一、迭代器 1.Iterator 概念：Iterator是一个接口，它是集合的迭代器，集合可以通过Iterator去遍历集合中的元素，常用API接口： hasNext():如果迭代器中还有元素，则返回true。 next():返回迭代器中的下一个元素。 remove():删除迭代器新返回的元素。 案例：使用Iterator遍历元素 public class Test { public static void main(String[] args) { ArrayList<St
Java Web从入门到精通光盘16
11-29
在这个“Java Web从入门到精通光盘16”中，您将深入学习这一领域的核心概念和实践技巧。 首先，让我们谈谈Servlet。Servlet是Java编程语言中用于扩展服务器功能的接口，它允许程序员创建动态响应HTTP请求的应用程序...
配置Java开发环境
Broken_x的博客
07-10 1275
Java开发环境配置
java集合工具类
最新发布
hejiefeng111的博客
07-12 196
【代码】java集合工具类。
java版的上门家政系统和PHP版的上门家政有什么区别？
baina666的博客
07-12 259
综上所述，Java版和PHP版的上门家政系统各有优缺点，选择哪种语言主要取决于项目的具体需求、预算、开发团队的技术栈以及未来的扩展计划等因素。同时，由于Java生态系统的复杂性和多样性，也可能需要投入更多的时间和资源来学习和掌握相关的技术和工具。Java版：Java拥有庞大的生态系统和丰富的第三方库，这为家政系统的开发和扩展提供了强大的支持。Java版：由于Java的编译执行机制和高效的垃圾回收算法，Java版家政系统通常具有更高的运行效率和更好的性能表现，尤其是在处理高并发、大数据量等复杂场景时。
关于static定义初始化块和静态变量以及初始化块的执行顺序问题
你我约定有三的博客
07-08 403
第二步：在类加载的时候，按照从上到下执行static修饰的代码，此时执行static Test2 test1 = new Test2()，也就是创建出一个名为test1的对象。第六步：此时除了main方法，所有由static修饰的代码全部执行完毕(static修饰的代码只执行一次)，类初始化完成，开始执行main方法，main方法中只有一条语句(中的代码,此时输出aa以及a的值(由于第一步没赋初值，并且给了默认值为0 所以输出0)//首先输出a的值为10 然后输出bb，最后将a的值定义为11。
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
小明的Java问道之路
07-08 2093
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
java Object 转 Integer
servepeople的博客
07-09 1384
在 Java 中，可以通过多种方法将一个Object转换为Integer。
JAVA入门.docx
12-30
java 入门

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值