线程是任务调度和执行的基本单位,可以看做是轻量级的进程,多线程是指在同一程序中有多个顺序流在执行,也就是一个进程中同时执行多个线程,两个或两个以上的线程对同一个变量的操作.如果两个线程修改同一个对象的状态,根据线程访问数据的次序,可能会产生错误的数据,也就常说的并发问题.
在学线程之前,首先来来了解一下线程与进程的区别:
进程:
线程:
线程和进程一样分为五个阶段：创建、就绪、运行、阻塞、终止
创建的线程有四种方式:
1.继承Thread类
class TestThread extends Thread{
private volatile int ticket = 10;
@Override
public void run() {
synchronized (this){
while (ticket > 0){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "卖票操作 ticket = "+ticket--);
}
}
}
}public class Test{
public static void main(String[] args) throws Exception{
TestThread testThread = new TestThread();
testThread.run();
}
}运行结果:
2.实现Runnable接口
经典的生产者和消费者
class Product implements Runnable{//生产者
private Message message;
Product(Message message) {
this.message = message;
}
public void run() {
for (int x = 0 ; x < 100 ; x++){
if (x % 2 == 0){
this.message.set("生产者","生产");
}else {
this.message.set("消费者","消费");
}
}
}
}
----
class Consumer implements Runnable{//消费者
private Message message;
public Consumer(Message message) {
this.message = message;
}
public void run() {
for (int x = 0 ; x < 100 ; x++){
System.out.println(this.message.get());
}
}
}
----
class Message{ //消息中心
private String title;
private String content;
private boolean flag = true;//表示生产或者消费的形式
// flag = true 允许生产,不允许消费 flag= false 允许消费,不允许生产
synchronized void set(String title, String content){
if (!flag){
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
this.title = title;
this.content = content;
this.flag = false; //生产完成
notify();//唤醒等待的线程
}
synchronized String get(){
if (flag == true){
try {
super.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
try {
return this.title + " ------------ "+this.content;
}finally {
this.flag = true; // 可继续生产
notify();//唤醒等待线程
}
}
}
----
public class Producer {
public static void main(String[] args) throws Exception{
Message message = new Message();
new Thread(new Product(message),"生产者").start();//启动生产者线程
new Thread(new Consumer(message),"消费者").start();//启动消费者线程
}
}运行结果
3.实现Callable接口
class TheThread implements Callable<String>{
private boolean flag = false;
@Override
public String call() throws Exception {
synchronized (this){
if (this.flag==false){
this.flag = true;
return Thread.currentThread().getName()+"抢答成功";
}else {
return Thread.currentThread().getName()+"抢答失败";
}
}
}
}public class Competition {
public static void main(String[] args) throws ExecutionException, InterruptedException {
TheThread theThread = new TheThread();
FutureTask<String> futureTaskA = new FutureTask<>(theThread);
FutureTask<String> futureTaskB = new FutureTask<>(theThread);
FutureTask<String> futureTaskC = new FutureTask<>(theThread);
new Thread(futureTaskA,"竞赛者A").start();
new Thread(futureTaskB,"竞赛者B").start();
new Thread(futureTaskC,"竞赛者C").start();
System.out.println(futureTaskA.get());
System.out.println(futureTaskB.get());
System.out.println(futureTaskC.get());
}
}运行结果
4.使用线程池
class ExecutorTest{
public static void main(String[] args) {
ExecutorService executorService = Executors.newCachedThreadPool();
executorService.submit(new Runnable() {
@Override
public void run() {
for (int i = 0;i<10;i++){
System.out.println(i);
}
}
});
}
}运行结果
以上案例都是处理过的线程,都是通过使用了synchronized锁保证了原子性,也就是线程安全的操作,线程的安全的实现方式,除了使用锁之外,也可以用CAS实现无锁安全操作.
示例:
class CAS{
private AtomicInteger ticket = new AtomicInteger(10);
public void run() {
while (ticket.get()>0){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "卖票操作 ticket = "+ticket.getAndDecrement());
}
}
}----
public class CASTest{
public static void main(String[] args) throws Exception{
CAS cas = new CAS();
cas.run();
}
}程序执行结果
以上是使用了atomic包下线程安全的AtomicInteger,下面是atomic包下的线程安全类以及部分源码
Atomiclnteger本身是个整型,最重要的属性是value,而value使用了volatile关键字,value的作用就是保证可见性,即一个线程修改了共享变量时,其他线程读取的是修改后的新值.
getAndIncrement()方法实现了自增操作.核心实现是先获取当前值和目标值如果compareAndSet(current,next)成功返回该方法的目标值.getAndDecrement()方法则实现了自减操作.
AtomicInteger中的CAS操作就是compareAndSet(),作用是每次从内存中根据内存偏移量(valueOffset)取出数据,将取出的值跟expect比较,如果数据一致就把内存中的值改为update.这样就保证了原子操作.
AtomicInteger主要实现了整型的原子操作,防止并发的情况下出现异常结果,内部主要依靠JDK中的unsafe类操作内存中的数据实现.volatile修饰符保证了可见性,CAS操作保证了原子操作
若某一属性使用volatile关键字,则表示不操作副本,直接操作原始变量.
volatile关键字的两层含义:
一旦一个共享变量(类的成员变量,类的静态成员变量)被volatile修饰之后,那么久具体两层语义:
volatile关键字需要结合锁来使用
示例:
class MyThread implements Runnable{
private volatile int ticket = 10;
@Override
public void run() {
synchronized (this){
while (ticket > 0){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "卖票操作 ticket = "+ticket--);
}
}
}
}public class Volatile{
public static void main(String[] args) throws Exception{
MyThread myThread = new MyThread();
new Thread(myThread,"票贩子A").start();
new Thread(myThread,"票贩子B").start();
new Thread(myThread,"票贩子C").start();
}
}运行结果
本案例与上面的继承Thread类的案例是同一个.
在并发编程中会遇到三个问题:原子性、可见性、有序性
可以通过volatile关键字来保证一定的"有序性",也可以通过synchronized和lock来保证有序性,synchronized和lock保证每一刻只有一个线程执行同步代码,相当于让线程顺序执行同步代码,自然就保证了有序性.
java内存模型具备一些先天的"有序性",即不需要通过任何手段就能够保证有序性,这个通常也称为happens-before原则(先行发生原则).如果两个操作的执行次序无法从happens-before原则推导出来,那么他们就不能保证它们的有序性,虚拟机可以随意的对它们进行重排序.
happens-before原则(先行发生原则):
public class Daemon {
public static void main(String[] args) throws Exception{
Thread userThread = new Thread(() -> {
for (int x = 0 ; x < 10 ; x++) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "正在执行 x = " + x);
}
},"执行线程");
Thread daemonThread = new Thread(() -> {
for (int x = 0 ; x < Integer.MAX_VALUE ; x++){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "正在执行 x = " + x);
}
},"守护线程");
daemonThread.setDaemon(true);//将daemonThread设为守护线程
userThread.start();
daemonThread.start();
}
}运行结果
在Thread类提供了以下的守护线程的操作方法,可自行查看源码
public final void setDaemon(boolean on) {
checkAccess();
if (isAlive()) {
throw new IllegalThreadStateException();
}
daemon = on;
}public final boolean isDaemon() {
return daemon;
}
public class StopThread {
public static boolean flag = true;
public static void main(String[] args) throws Exception{
new Thread(() -> {
long num = 0;
while (flag){
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "正在执行 num = " + num++);
}
},"执行线程").start();
Thread.sleep(200);//线程运行200毫秒
flag = false;//停止线程
}
}运行结果
多线程操作中使用的启动线程的方法是Thread类的start()方法,原本也提供有stop()方法来停止线程,但在1.2之后已经废除,现在停止线程的方法可使用上面案例所使用方式.
以上是线程的基本概念以及基础操作,若有不足或错误,欢迎指出.
微信关注我们
转载内容版权归作者及来源网站所有！
低调大师中文资讯倾力打造互联网数据资讯、行业资源、电子商务、移动互联网、网络营销平台。持续更新报道IT业界、互联网、市场资讯、驱动更新,是最及时权威的产业资讯及硬件资讯报道平台。
马里奥是站在游戏界顶峰的超人气多面角色。马里奥靠吃蘑菇成长，特征是大鼻子、头戴帽子、身穿背带裤，还留着胡子。与他的双胞胎兄弟路易基一起，长年担任任天堂的招牌角色。
Nacos /nɑ:kəʊs/ 是 Dynamic Naming and Configuration Service 的首字母简称，一个易于构建 AI Agent 应用的动态服务发现、配置管理和AI智能体管理平台。Nacos 致力于帮助您发现、配置和管理微服务及AI智能体应用。Nacos 提供了一组简单易用的特性集，帮助您快速实现动态服务发现、服务配置、服务元数据、流量管理。Nacos 帮助您更敏捷和容易地构建、交付和管理微服务平台。
Rocky Linux（中文名：洛基）是由Gregory Kurtzer于2020年12月发起的企业级Linux发行版，作为CentOS稳定版停止维护后与RHEL（Red Hat Enterprise Linux）完全兼容的开源替代方案，由社区拥有并管理，支持x86_64、aarch64等架构。其通过重新编译RHEL源代码提供长期稳定性，采用模块化包装和SELinux安全架构，默认包含GNOME桌面环境及XFS文件系统，支持十年生命周期更新。
Sublime Text具有漂亮的用户界面和强大的功能，例如代码缩略图，Python的插件，代码段等。还可自定义键绑定，菜单和工具栏。Sublime Text 的主要功能包括：拼写检查，书签，完整的 Python API ， Goto 功能，即时项目切换，多选择，多窗口等等。Sublime Text 是一个跨平台的编辑器，同时支持Windows、Linux、Mac OS X等操作系统。
扫码在手机上查看文章
扫描二维码，手机阅读更方便
有任何问题或合作意向欢迎联系我们
Email: 99873273@qq.com
QQ: 99873273