Java并发/多线程

Java多线程

实现线程的两种方法:

a. 继承Thread类,start()启动。

b. 实现Runnable接口,实现run方法。

 

1. 基本线程

package com.sam.thread;

public class SimpleThread extends Thread {
    private int countDown = 5;
    private static int threadCount = 0;

    public SimpleThread() {
        super(" " + ++threadCount); // store the thread name
        start();
    }

    public String toString() {
        return "#" + getName() + ": " + countDown;
    }

    public void run() {
        while (true) {
            System.out.println(this);
            if (--countDown == 0)
                return;
        }
    }

    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            new SimpleThread();
        }
    }
}

package com.sam.thread;

public class SimpleThread extends Thread {
	private int countDown = 5;
	private static int threadCount = 0;

	public SimpleThread() {
		super(" " + ++threadCount); // store the thread name
		start();
	}

	public String toString() {
		return "#" + getName() + ": " + countDown;
	}

	public void run() {
		while (true) {
			System.out.println(this);
			if (--countDown == 0)
				return;
		}
	}

	public static void main(String[] args) {
		for (int i = 0; i < 5; i++) {
			new SimpleThread();
		}
	}
}

结果:

# 1: 5
# 1: 4
# 1: 3
# 1: 2
# 1: 1
# 3: 5
# 3: 4
# 3: 3
# 3: 2
# 3: 1
# 2: 5
# 5: 5
# 5: 4
# 5: 3
# 5: 2
# 5: 1
# 2: 4
# 2: 3
# 2: 2
# 2: 1
# 4: 5
# 4: 4
# 4: 3
# 4: 2
# 4: 1
 

 

 

2.yield(),让步,让其它线程使用CPU,可以让结果更均衡。

package com.sam.thread;

public class YieldThread extends Thread {
	private int countDown = 5;
	private static int threadCount = 0;

	public YieldThread() {
		super(" " + ++threadCount); // store the thread name
		start();
	}

	public String toString() {
		return "#" + getName() + ": " + countDown;
	}

	public void run() {
		while (true) {
			System.out.println(this);
			if (--countDown == 0)
				return;
			yield();
		}
	}

	public static void main(String[] args) {
		for (int i = 0; i < 5; i++) {
			new YieldThread();
		}
	}
}

 结果:

# 1: 5
# 2: 5
# 3: 5
# 1: 4
# 2: 4
# 5: 5
# 3: 4
# 1: 3
# 5: 4
# 3: 3
# 1: 2
# 5: 3
# 3: 2
# 1: 1
# 5: 2
# 4: 5
# 3: 1
# 5: 1
# 2: 3
# 4: 4
# 2: 2
# 2: 1
# 4: 3
# 4: 2
# 4: 1

 

3. sleep, 休眠一段时间再执行

package com.sam.thread;

public class SleepThread extends Thread {
	private int countDown = 5;
	private static int threadCount = 0;

	public SleepThread() {
		super(" " + ++threadCount); // store the thread name
		start();
	}

	public String toString() {
		return "#" + getName() + ": " + countDown;
	}

	public void run() {
		while (true) {
			System.out.println(this);
			if (--countDown == 0)
				return;
			try {
				sleep(100);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}

	public static void main(String[] args) {
		for (int i = 0; i < 5; i++) {
			new SleepThread();
		}
	}
}

 结果:

# 1: 5
# 3: 5
# 2: 5
# 5: 5
# 4: 5
# 1: 4
# 2: 4
# 4: 4
# 3: 4
# 5: 4
# 1: 3
# 2: 3
# 3: 3
# 4: 3
# 5: 3
# 2: 2
# 4: 2
# 3: 2
# 1: 2
# 5: 2
# 1: 1
# 2: 1
# 4: 1
# 3: 1
# 5: 1

 

4. 优先级 setPriority();

package com.sam.thread;

public class PriorityThread extends Thread {
	private int countDown = 5;
	private static int threadCount = 0;

	public PriorityThread(int priority) {
		super(" " + ++threadCount); // store the thread name
		setPriority(priority);
		start();
	}

	public String toString() {
		return "#" + getName() + ": " + countDown;
	}

	public void run() {
		while (true) {
			System.out.println(this);
			if (--countDown == 0)
				return;			
		}
	}

	public static void main(String[] args) {
		new PriorityThread(Thread.MAX_PRIORITY);
		for (int i = 0; i < 5; i++) {
			new PriorityThread(Thread.MIN_PRIORITY);
		}
	}
}

 结果:优先级高的先运行

# 1: 5
# 1: 4
# 1: 3
# 1: 2
# 1: 1
# 3: 5
# 3: 4
# 3: 3
# 3: 2
# 3: 1
# 5: 5
# 5: 4
# 5: 3
# 5: 2
# 5: 1
# 2: 5
# 2: 4
# 2: 3
# 2: 2
# 2: 1
# 4: 5
# 4: 4
# 4: 3
# 6: 5
# 6: 4
# 6: 3
# 6: 2
# 6: 1
# 4: 2
# 4: 1

 

5. 后台线程(daemon)

当所有非后台线程结束,线程终止。如:某个时刻线程都sleep了,程序终止。

package com.sam.thread;

public class DaemonThread extends Thread {
	private int countDown = 5;
	private static int threadCount = 0;

	public DaemonThread() {
		super(" " + ++threadCount); // store the thread name
		setDaemon(true);
		start();
	}

	public String toString() {
		return "#" + getName() + ": " + countDown;
	}

	public void run() {
		while (true) {
			System.out.println(this);
			if (--countDown == 0)
				return;
			try {
				sleep(100);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}

		}
	}

	public static void main(String[] args) {
		for (int i = 0; i < 5; i++) {
			new DaemonThread();
		}
	}
}

 结果:

# 1: 5
# 3: 5
# 5: 5
# 4: 5
# 2: 5

 

6. join()和interrupt()

package com.sam.thread;

class A extends Thread {
	public A() {
		start();
	}
	public void run() {
		try {
			System.out.println("A started.");
			sleep(1000);
		} catch (InterruptedException e) {
			System.out.println("Sleep interrupted");
		}
	}
}

public class JoinThread extends Thread {
	A a;
	public JoinThread(A a) {
		this.a = a;
		start();
	}
	public void run() {
	
		try {
			a.join();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println("JoinThread started.");
	}
	public static void main(String[] args) {
		A a = new A();
		JoinThread jt = new JoinThread(a);
		a.interrupt();
	}
}

 结果:

A started.
Sleep interrupted
JoinThread started.

 

7. Runnable接口

package com.sam.thread;

public class RunnableThread implements Runnable {

	private int countDown = 5;

	public String toString() {
		return "#" + Thread.currentThread().getName() + ": " + countDown;
	}

	@Override
	public void run() {
		while (true) {
			System.out.println(this);
			if (--countDown == 0)
				return;
		}
	}

	public static void main(String[] args) {
		for (int i = 1; i <= 5; i++) {
			new Thread(new RunnableThread(), "" + i).start();
		}
	}
}

runnable接口本身不带线程的特性,要运行,还是要建立一个单独的Thread对象。

 

8. 不正确地访问资源

package com.sam.thread;

public class AlwaysEven {
	int i;

	void next() {
		i++;
		i++;
	}

	int get() {
		return i;
	}

	public static void main(String[] args) {
		final AlwaysEven ae = new AlwaysEven();
		new Thread() {
			public void run() {
				while (true) {
					int j = ae.get();
					if (j % 2 != 0) {
						System.out.println(j);
						System.exit(0);
					}
				}
			}
		}.start();
		while (true) {
			ae.next();
		}
	}
}

 结果:

1501

 

9. 解决共享资源竞争

在每个访问共享资源的方法上都要加上synchronized,否则不加的方法会忽视该锁。

package com.sam.thread;

public class AlwaysEven {
	int i;

	synchronized void next() {
		i++;
		i++;
	}

	synchronized int get() {
		return i;
	}

	public static void main(String[] args) {
		final AlwaysEven ae = new AlwaysEven();
		new Thread() {
			public void run() {
				while (true) {
					int j = ae.get();
					if (j % 2 != 0) {
						System.out.println(j);
						System.exit(0);
					}
				}
			}
		}.start();
		while (true) {
			ae.next();
		}
	}
}

 

10. volatile

禁止编译器进行优化,线程不能保留该对象的私有拷贝,影响效率。

 

11. 临界区

防止多个线程访问方法中的部分代码。

synchronized(syncObject) {
    // This code can only be access
    // by one thread at a time
}

 

12. 线程的状态

新建(new)

就绪(Runnable)

死亡(Dead)

阻塞(Blocked)

 

13. notify()

唤醒wait()中的线程。

 

zz

Centos7.9使用kubeadm部署K8S集群 使用kubeadm部署一个k8s集群,单master+2worker节点。 阅读详情

相关推荐

全网最全医学图像数据汇总

本仓库汇总了多个领域的医学图像开源数据集,涵盖CT、MRI、超声、内窥镜、病理、多模态、PET、OCT以及皮肤镜等多种成像技术。每个数据集均详细列出了任务类型、部位、格式、数量及下载链接,旨在为医学图像研究者提供便捷的资源导航。⚠️:这些数据集仅适用于学术研究用途。

2401_83173765的博客 3319

Java并发编程01:Java多线程基础(synchronized,volatile,wait/notify)

多线程基础多线程基础多线程基础多线程基础多线程基础多线程基础多线程基础多线程基础多线程基础多线程基础多线程基础多线程基础多线程基础多线程基础多线程基础多线程基础多线程基础多线程基础多线程基础多线程基础多线程基础多线程基础多线程基础多线程基础多线程基础多线程基础多线程基础多线程基础多线程基础多线程基础多线程基础多线程基础 ...

ncepu_Chen的博客 2739

mt7601 kernel 4.19内核集成版本,以及源码编译相关问题

/os/linux/Makefile.6文件: 添加 EXTRA_CFLAGS += -Wno-incompatible-pointer-types -Wno-date-time。看下iwpriv与iwconfig的源码区别,左侧为iwconfig ,没有用到ioctl,右侧为iwpriv。1、init_timer kernel 4.19内核版本API已经改变,使用timer_setup。使用iwpriv 提示如下,iwpriv工具无法使用了,而iwconfig可以使用。makefile的修改。

1593

Java多线程与高并发专题——Condition 和 wait/notify的关系

Java多线程与高并发专题——Condition 和 wait/notify的关系

从知识输入到知识输出 1401

解决redhat8/centos8无法使用yum问题(报错:This system is not registered to Red Hat Subscription Management)

解决redhat无法使用yum问题、以及替换repo文件后仍无法使用yum的问题

qq_43569119的博客 4342

用Python手把手教你实现一个多层感知机(MLP)——从理论到代码实战

本文详细介绍了如何使用Python和Theano库从零开始实现多层感知机(MLP),涵盖从核心原理到代码实战的全过程。通过构建隐藏层、输出层和完整MLP模型,结合权重初始化、激活函数选择和训练技巧,帮助开发者深入理解神经网络工作机制,并应用于实际机器学习任务。

web39explorer的博客 971

JAVA 多线程/并发

高并发、多线程 多线程 线程和进程 进程是程序的⼀次执⾏过程,系统资源分配的基本单位,线程是⼀个⽐进程更⼩的执⾏单位,CPU调度的基本单位,⼀个进程在其执⾏的过程中可以产⽣多个线程。 每个进程具有自己独立的地址空间,进程之间是相互独立的。 栈是线程私有的,堆是线程共享的.同类的多个线程共享进程的堆和⽅法区资源,但每个线程有⾃⼰的程序计数器、虚拟机栈和本地⽅法栈 进程上下文切换比线程开销大得多。 JAVA内存模型(JMM)  Java内存模式是一种虚拟机规范,JMM规范了Java虚拟机与计算机内存是如何协

qq_40860346的博客 614

1.1.4 运用防火墙实现入侵防御

摘要:本文详细介绍了某公司网络拓扑中防火墙FW1的配置过程。主要内容包括:1)通过web界面登录防火墙;2)配置三个接口的IP地址及所属安全区域;3)创建两个入侵防御配置文件(anti_untrust和anti_trust);4)配置安全策略untrust2dmz和trust2dmz,分别允许公网/内网访问WWW服务器;5)保存配置。操作步骤配有详细截图说明,涉及接口配置、安全区域划分、入侵防御策略设定等关键环节,最终实现内外网对服务器Server1的安全访问控制。(149字)

Ljs040411的博客 2137

【Java并发】多线程/并发问题集

【Java并发】多线程/并发问题集

hiliang521的博客 785

流程图详解Transformer最核心的多头注意力机制,QKV流向清晰明了

本文详细讲解了Transformer模型中的多头注意力机制(Multi-head Attention)。通过类比多人评估同一事物的不同视角,说明多头机制能综合多个注意力权重获得更有效的输出。文章逐步推导了多头注意力的计算过程:将输入矩阵X(4×512维)分别与8组Q、K、V权重矩阵相乘,得到8组head(每组4×64维),拼接后经Wo矩阵变换恢复为4×512维输出。整个过程涉及37个待训练参数矩阵(1个Wo、8组Wq/Wk/Wv)。该机制通过并行计算多个注意力头,能更全面捕捉输入特征间的复杂关系。

人工智能研究所的博客 268

仿真学习系列(三十八):Sigrity仿真之单端S参数提取

S 参数(Scattering Parameters)是高速信号分析中最基础也最常用的指标,能够全面表征走线、过孔、连接器等互连结构的高频行为。在 Sigrity PowerSI 中,Model Extraction 是最常用的 S 参数提取方式,适用于高速差分线、单端线、过孔、参考平面等各种拓扑结构。 本节将通过示例讲解如何在 PowerSI 中完成一次完整的 S 参数提取流程,包括:对象选择、端口设置、频率范围配置以及结果查看。掌握此方法后,即可对任意高速网络执行阻抗、插损、回损、串扰分析,为进一步的

案例文章,高速信号 838

Java多线程 - 并行/并发/进程/线程/多线程意义

1. 并行和并发有什么区别? 并发和并行都可以处理“多任务”,二者的主要区别在于是否是“同时进行”多个的任务。 串行:按先后顺序做多件事情;例如:A事情完成,才能做B事情; 并行:指同一时刻同时做多件事情;比如:A事情和B事情同时进行; 并发:指同一时间间隔内做多件事情;比如:操作系统将CPU的时间片分时让给A事情和B事情,仿佛是同时执行; 并发:不同的代码块交替执行 并行:不同的代码块同时执行 (1) 并行:指在同一时刻,多个指令可以在多个处理器上同时执行。 (2) 并发:指在同一时

你今天真好看呀 2962

如何提高电路的抗干扰能力

本内容详细介绍了电源传导干扰处理,包括滤波、Feedthrough电容器、磁环、磁珠、屏蔽的使用与选型,EMC电磁兼容测试项目简介与要求,单片机与电源抗干扰处理等。

让你爱上电路设计 8610

Java并发(一)Java并发/多线程教程

在过去一台电脑只有单个CPU,并且在同一时间只能执行单个程序。后来出现的"多任务"意味着电脑在可以同时执行多个程序(AKA任务或者进程)。虽然那并不是真正意义上的"同时"。多个程序之间共享仅有的一个CPU。操作系统会切换正在运行着的进程,在每次切换之前都会运行它们其中一个一小会儿。多任务模型的产生给软件开发者带来了新的挑战。程序不再假设为可以一直占用CPU时间,也不再占有所有的内存或者任何其他的计...

weixin_34241036的博客 94

android 蓝牙通讯demo

android 下蓝牙通讯demo,实现了发现蓝牙,使能蓝牙,通过蓝牙发送消息。

lwip-2.0.3

lwip是瑞典计算机科学院(SICS)的Adam Dunkels 开发的一个小型开源的TCP/IP协议栈。实现的重点是在保持TCP协议主要功能的基础上减少对RAM 的占用。

Java并发/多线程指南

在过去,计算机只有一个CPU,并且同一时刻只能执行一个程序。后来出现了多任务处理,这意味着计算机可以同时执行多个程序(AKA任务或进程)。然而,它并非真正“在同一时间”。单个CPU在程序之间共享。操作系统将在运行的程序之间切换,在切换之前执行每个程序一段时间。 随着多任务处理出现,软件开发人员面临着新的挑战。程序可能不在假设拥有所有可用的CPU时间,也不能假设所有内存或其他计算机资源。一个好的程...

Geek_ymv的专栏 311

NTscan扫描工具

ntscan是一个扫描器,可以扫描没有密码和弱密码的共享,先到配置文件中填写猜测的用户名和密码,扫描过程中右侧出现的是扫描日志。

Java 并发 / 多线程教程

Java 并发 / 多线程教程原文链接:http://tutorials.jenkov.com/java-concurrency/index.html内容列表 Java 中的多线程和并发 Java 并发 2015 和展望 最开始的计算机只有一个 CPU ,一次也只能执行一个程序。后来,出现了多任务操作系统,在宏观上能同时执行多个程序。实际上,在同一时刻只能执行一个程序,多个程序共享一个 CPU 。操

1248

汉书HE8,好用的汇编代码编写工具

汉书HE8,好用的汇编代码编写工具早期编写汇编代码所用功能强大

Java并发/多线程教程

过去计算机有一个单CPU,只能一次执行一个程序。后来计算机可以处理多任务,这意味着计算机可以同时执行多个程序(AKA任务或进程)。但是这不是真的“同时”。单个CPU在程序之间共享。操作系统将在运行的程序之间切换,在切换之前执行每个程序一段时间。 随着多任务处理,软件开发人员面临新的挑战。程序不能再假定所有的CPU时间可用,也不能全部内存或任何其他计算机资源。 “好公民”计划应该释放所有不再使用的资

loredp的博客 889

Java 并发/多线程教程——4并发模型

本系列译自jakob jenkov的Java并发多线程教程(本章节部分内容参考http://ifeve.com/并发编程模型),个人觉得很有收获。由于个人水平有限,不对之处还望矫正! 并发系统可以有多种并发模型来实现,并发模型指定线程如何协同完成分配给他们的任务。不同的并发模型以不同的方式划分任务,并且线程与...

weixin_34240520的博客 149

java 并发抢单_Java多线程并发编程/锁的理解

一.前言最近项目遇到多线程并发的情景(并发抢单&恢复库存并行),代码在正常情况下运行没有什么问题,在高并发压测下会出现:库存超发/总库存与sku库存对不上等各种问题。在运用了 限流/加锁等方案后,问题得到解决。加锁方案见下文。二.乐观锁 & 悲观锁1.乐观锁顾名思义,就是很乐观,每次去拿数据的时候都认为别人不会修改,所以不会上锁,但是在更新的时候会判断一下在此期间别人有没有去更新这...

weixin_39712724的博客 821

java多线程/并发学习笔记

java多线程/并发学习小结 线程 Runnable\Callable(FeatureTask可以返回结果)\继承Thread类;实现接口比继承人更好,java不支持多继承,但是可以实现多个接口 Daemon守护线程:所有非守护线程结束时,程序结束,会同时杀死所有守护线程 Thread.sleep()\InterruptException thread.interrupt():中断线程,如果线程处于阻塞(除了I/O阻塞和synchronized锁阻塞)或者等待状态则会抛出InterruptExceptio

guangdeshishe的博客 295

JAVA多线程高并发之ReentrantLock讲解lock/unlock/tryLock方法

JAVA中多线程高并发场景下保证线程安全通常都会考虑加锁。但是在特殊场景下我们也可以采用java.util.concurrent包提供的线程安全的对象,避免加锁从而达到高效的目的。 但是,这些线程安全的对象仅仅指的是针对于原子性操作是线程安全的,如果多个方法同时调用无法保证线程安全,只能考虑加锁。这里我们举个列子:假设我们在多线程高并发场景下使用java.util.concurrent.Conc...

饶艳辉 3051

Linux进程、线程、协程,Java/Golang多线程并发

Linux processes, threads, coroutines, java/golang multithreading concurrency

Trollz的博客 1139

面试准备-Java并发/多线程总结

Java并发/多线程总结

m0_52248951的博客 292

多线程导出excel高并发_2020大厂JAVA高频面试题-多线程 / 高并发最新面试题

1. stop() 和 suspend() 方法为何不推荐使用? 反对使用 stop(),是因为它不安全。它会解除由线程获取的所有锁定,而且如果对象处于一种不连贯状态,那么其他线程能在那种状态下检查和修改它们。结果很难检查出真正的问题所在。 suspend() 方法容易发生死锁。调用 suspend() 的时候,目标线程会停下来,但却仍然持有在这之前获得的锁定。此时,其他任何线程都不能访问锁定的资...

weixin_34008445的博客 174

Java_—多线程的引入/并发和并行的区别

一、什么是多线程 线程是程序执行的一条路径, 一个进程中可以包含多条线程 多线程并发执行可以提高程序的效率, 可以同时完成多项工作 二、多线程的应用场景 迅雷开启多条线程一起下载 QQ同时和多个人一起视频 服务器同时处理多个客户端请求 三、多线程并行和并发的区别 并行:是两个任务同时运行,就是甲任务进行的同时,乙任务也在进行。(需要多核CPU) 比如我跟两个网友聊天,左手操作一个电脑跟甲聊,同时右...

qq_36722925的博客 149
上一篇: ServiceMix
下一篇: 英文面试问题
O2AtomLife
博客等级 码龄19年 2粉丝 82原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值