线程同步

最新推荐文章于 2024-10-12 17:55:45 发布
最新推荐文章于 2024-10-12 17:55:45 发布
阅读量102 收藏
点赞数
分类专栏： java 编程 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45840774/article/details/117522465
版权
java 同时被 2 个专栏收录
18 篇文章 0 订阅
订阅专栏
编程
6 篇文章 0 订阅
订阅专栏

线程同步-可见性（非线程安全）

    （1）在并发线程中存在的线程安全问题，主要原因有

               [1]存在共享数据

               [2]多线程共同操作共享数据

    （2）volatile关键词---可见性(Visibility)

               [1] 功能：volatile关键字的作用很简单，就是一个线程在对主内存的某一份数据进行更改时，更改之后会立刻刷新主内存，并且会强制让缓存了该变量的线程中的数据清空，必须从主内存重新读取最新数据，这样一来就保证了可见性

               [2] 案例分析（注意volative关键字的作用，可以尝试将该关键词删除后进行运行）

package com.experiment_2_Thread.four;

public class TestVo  extends Thread{
	//stop相当于是一个环境变量
	//我们加入了一个volatile关键词，实现了刷新主内存的作用
	public volatile static boolean stop=false;
	@Override
	public void run() {
		  System.out.println("我开始了");
		  while (!stop) {
					
		}
		  System.out.println("我结束了");
	}

	//我们将sleep可能产生的异常进行抛出
	public static void main(String[] args) throws InterruptedException {
	  	TestVo testVo=new TestVo();
	  	testVo.start();
	  	//当前线程睡眠2s
	  	Thread.sleep(2000);
	  	stop=true;
	}
}

线程同步-原子性

    （1）介绍：

             [1]进入区（申请资源）------ 资源被占用，暂时不能访问，进入阻塞等待队列

             [2]临界区 -----只能有一个线程

             [3]退出去（释放资源）

    （2）Synchronized关键字

             [1]概述：java中每一个对象都可以有锁，这是Synchronized实现同步的基础

             [2]三种应用方式：

                       {1}普通同步方法（实例方法），锁是当前实例对象，进入同步代码前要获得当前实例的锁

                       {2}静态同步方法，锁是当前类的class对象，进入同步代码前要获得当前类对象的锁

                       {3}同步方法块，锁是括号里面的对象，对给定对象加锁，进入同步代码库前要获得给定对象的锁

             [3]案例分析

 

{普通同步方法}

  {T1线程}

package com.experiment_2_Thread.four;

public class T1 implements Runnable {
    synchronized public void f1() {
        System.out.println(Thread.currentThread().getName()+"开始了");
        try {
            //让线程进行休眠2s
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"结束了");
    }

    @Override
    public void run() {
        // TODO Auto-generated method stub
        f1();
    }

}

{Testsy}

package com.Test_P;

public class Testsy {
	public static void main(String[] args) {
		T1 t=new T1();
		Thread t1 = new Thread(t,"测试1");
		Thread t2 = new Thread(t,"测试2");
		t1.start();
		t2.start();
	}
}

运行结果：线程1和线程2依次进行运行，线程1运行结束后才开始运行线程2

 

{静态同步方法}

{T1线程}

package com.Test_P;

public class T1 implements Runnable {
	synchronized static public void f1() {
		System.out.println(Thread.currentThread().getName()+"开始了");
		try {
			//让线程进行休眠2s
			Thread.sleep(2000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println(Thread.currentThread().getName()+"结束了");
	}

	@Override
	public void run() {
		// TODO Auto-generated method stub
		f1();
	}

}

{Testsy}

package com.Test_P;

public class Testsy {
	public static void main(String[] args) {
		T1 t=new T1();
		T1 tt=new T1();
		Thread t1 = new Thread(t,"测试1");
		Thread t2 = new Thread(t,"测试2");
		Thread t3 = new Thread(tt,"测试3");
		t1.start();
		t2.start();
		t3.start();
	}
}

静态同步方法才让线程1，线程2，线程3依次执行，否则由于t3和t1，t2的对象不同会导致交错运行的结果

这个静态方法锁相当于是给类上了一个锁，只要是调用这个类的就必须要有锁

 

{同步方法块}

{不需要同步的System.out.println("测试")我们就没有放到同步语句块中}

{最上面的那个Object object = new Object(); 如果没有static就相当于普通同步方法}

package com.experiment_2_Thread.four;

public class T1 implements Runnable {
	//Object object=new Object();
	static Object object=new Object();
	public void f1() {
		System.out.println("测试");
		synchronized(object) 
		{
  			System.out.println(Thread.currentThread().getName()+"开始了");
			try {
				//让线程进行休眠2s
				Thread.sleep(2000);
			} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
			}
  			System.out.println(Thread.currentThread().getName()+"结束了");
		}
	
	}

	@Override
	public void run() {
		// TODO Auto-generated method stub
		 f1();
	}

}

{Testsy}

package com.experiment_2_Thread.four;

public class Testsy {
    public static void main(String[] args) {
	    T1 t=new T1();
	    T1 tt=new T1();
	    Thread t1=new Thread(t,"测试1");
	    Thread t2=new Thread(t,"测试2");
	    Thread t3=new Thread(tt,"测试3");
	    t1.start();
	    t2.start();
   	    t3.start();
    }
}

    （3）sychronized的缺点

             [1]效率低

             [2]锁的释放情况少，只在程序正常执行完成和抛出异常时释放锁

             [3]试图获得锁是不能设置超时的

             [4]不能中断一个正在试图获得锁的线程

             [5]无法知道是否成功获得到锁

Lock接口与ReentrantLock接口

    （1）与synchronized关键字相同的地方：他们实现的功能是一样的

    （2）与synchronized关键字不同的地方：

             [1]Lock有比synchronized更精确的线程语义和更好的性能

             [2]synchronized会自动释放锁，Lock要求程序员手工释放，且必须在finally语句中

    （3）使用锁进行同步机制（实例）

  {T2线程}

package com.experiment_2_Thread.four;

import java.util.concurrent.locks.ReentrantLock;

public class T2 implements Runnable {
    ReentrantLock r=new ReentrantLock();
    public void f1() {
        r.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "开始了");
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();

            }
            System.out.println(Thread.currentThread().getName() + "结束了");
        }
        //因为还锁只能在finally中进行所以必须要加try语句块
        finally {
            r.unlock();
        }
    }
    @Override
    public void run() {
        // TODO Auto-generated method stub
        f1();
    }
}

  {TestLock}

package com.experiment_2_Thread.four;

public class TestLock {
    public static void main(String[] args) {
        T2 t2=new T2();
        Thread thread1=new Thread(t2,"测试1");
        thread1.start();
        Thread thread2=new Thread(t2,"测试2");
        thread2.start();
    }
}

 

wait()和notify()

    （1）wait():导致当前线程等待，直到另一个线程调用该对象的notify()方法或notifyAll()方法

    （2）notify():唤醒正在等待的对象监视器的单个线程

    （3）notifyAll():唤醒正在等待的对象监视器的所有线程

    （4）实例分析

package com.experiment_2_Thread.four;

public class TestWait {
    static Object object = new Object();
    public static void main(String[] args) {
        Thread thread = new Thread(new Runnable() {
            public void run(){
                synchronized (object) {
                    System.out.println(Thread.currentThread().getName() + "开始了");
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    try {
                        object.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "结束了");
                }
            }
        });
        Thread thread1 = new Thread(new Runnable() {
            public void run(){
                synchronized (object) {
                    System.out.println(Thread.currentThread().getName() + "开始了");
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "结束了");
                    object.notify();
                }
            }
        });
        thread.start();
        thread1.start();
    }

}

 

Nefertari0
关注
专栏目录
JAVA线程同步
miqq_79872135的博客
03-23 2956
线程同步 线程同步：即当有一个线程在对内存进行操作时，其他线程都不可以对这个内存地址进行操作，直到该线程完成操作， 其他线程才能对该内存地址进行操作，而其他线程又处于等待状态，实现线程同步的方法有很多。 为什么要创建多线程？ 在一般情况下，创建一个线程是不能提高程序的执行效率的，所以要创建多个线程。 为什么要线程同步 多个线程同时运行的时候可能调用线程函数，在多个线程同时对同一个内存地址进行写入，由于CPU时间调度上的问题，写入数据会被多次的覆盖，所以就要使线程同步。 例如：我们去银行存钱，那肯定
QT线程同步技术详解
MingoJiang
06-18 1930
详细讲解QT的线程同步技术，初级锁，读写锁与条件锁的应用与注意事项
线程安全之可见性问题
qq_39787940的博客
01-08 427
文章目录线程安全之可见性问题1 Java内存模型2 JMM的抽象结构3 指令重排4 JIT编译器（Just In Time Compiler）5 volatile关键字6 final总结 线程安全之可见性问题 1 Java内存模型 Java内存模型（Java Memory Model，简称JMM。PS:注意与Java运行时数据区的区别），是针对Java在多线程并发下可能出现的各种问题而提出的一种规...
Java 内存模型：共享、可变、线程安全性、线程同步、原子性、可见性、有序性
追求幸福，探索未知的博客
03-02 277
Java内存模型的一些基本的概念：共享、可变、线程安全性、线程同步、原子性、可见性、有序性。 共享和可变   要编写线程安全的代码，其核心在于对共享的和可变的状态进行访问。   “共享”就意味着变量可以被多个线程同时访问。我们知道系统中的资源是有限的，不同的线程对资源都是具有着同等的使用权。有限、公平就意味着竞争，竞争就有可能会引发线程问题。   “可变”是指变量的值在其生命周期内是可以...
Android线程同步
easonguolong的博客
05-06 3318
一、为什么要线程同步 因为当我们有多个线程要同时访问一个变量或对象时，如果这些线程中既有读又有写操作时，就会导致变量值或对象的状态出现混乱，从而导致程序异常。举个例子，如果一个银行账户同时被两个线程操作，一个取100块，一个存钱100块。假设账户原本有0块，如果取钱线程和存钱线程同时发生，会出现什么结果呢？取钱不成功，账户余额是100.取钱成功了，账户余额是0.那到底是哪个呢？很难说清楚。因此多...
C#的线程同步
IT技术猿猴的博客
04-05 4141
使用线程有几个原因。假设从应用程序中进行网络调用需要一定的时间。我们不希望用户界面停止响应，让用户一直等待直到从服务器返回一个响应。用户可以同时执行其他一些操作，或者甚至取消发送给服务器的请求。这些都可以使用线程来实现。 线程是程序中独立的指令流。使用C编写任何程序时，都有一个入口点:Main()方法。程序从Main(方法的第一条语句开始执行，直到这个方法返回为止。 这种程序结构非常适合于其中有一个可识别的任务序列的程序，但程序常常需要同时完成多个任务。线程对客户端和服务器端应用程序都非常重要。
线程同步机制
欢迎一起学习交流
04-10 3985
目录 一、线程同步机制 ​ 二、同步方法 ​ 三、同步块 一、线程同步机制 处理多线程问题时，多个线程访问同一个对象，并且某些线程还想修改这个对象。这时需要线程同步，线程同步是一种等待机制，多个县农村需要同时访问此对象的线程进入这个对象的等待池形成队列，等待前面线程使用完毕，下一个线程再使用 解决方法：队列和锁 保证线程同步的安全性 由于同一进程的多个线程共享一块存储空间，在带来方便的同时，也带来了访问冲突问题，为了保证数据在方法中被访问时的正确性，在访问时加锁
多线程同步
Imzhipo的博客
07-11 3828
多线程 线程同步
C++多线程同步
书山有路勤为径
03-22 5190
摘要：本文介绍了C++11中如何开启新线程，并详细讲解了线程的基础同步原语：mutex, lock_guard, unique_lock, condition variable和semaphore等。如何采用async, packaged_task和promise实现future同步机制？怎样处理spurious wakeup?本文以质数判定服务为例为大家分享C++多线程同步措施！ 1. C++线程和基础同步原语 Thread mutex, lock_guard, unique_lock con.
Java多线程 - 线程同步
honvin的博客
09-22 3970
线程同步，主要是应用在多个线程操作同一个资源。 并发：同一个对象被多个线程同时操作。 例子： 上万人同时抢100张票 一个账号在两个银行同时取钱 现实生活中，并发情况很常见。比如，食堂排队打饭，每个人都想吃饭，最天然的解决办法就是排队，一个个来。 处理多线程问题时，多个线程访问同一个对象，并且某些线程还想修改这个对象这时候我们就需要线程同步。线程同步其实就是一种等待机制，多个需要同时访问，此对象的线程进入这个对象的等待池形成队列，等待前面线程使用完毕，下一个线程再使用。 排队的形成条件：队列 + 锁 由
11.Linux线程同步
01-06
文章目录一、线程同步的概念二、互斥锁1、初始化锁2、阻塞加锁3、非阻塞加锁4、解锁5、销毁锁（此时锁必需unlock状态，否则返回EBUSY）三、示例程序四、版权声明 一、线程同步的概念 线程同步？怎么同步？一起运行？...
java 实现线程同步的方式有哪些
09-05
Java中的线程同步是解决多线程环境下并发访问共享数据可能导致的数据不一致性问题的关键技术。在Java中，有多种方式可以实现线程同步，确保在任何时刻只有一个线程能够访问特定的共享资源。 1. **同步代码块 ...
深入解析Java的线程同步以及线程间通信
09-03
Java线程同步是多线程编程中的核心概念，它的目的是防止多个线程同时访问共享资源，从而避免数据不一致和竞态条件。在Java中，线程同步可以通过两种主要方式实现：同步方法和同步块。 1. **同步方法**： Java通过`...
多任务操作系统进程和线程同步控制
01-09
　1、临界区是线程同步的一种方式，即它在同一时刻只允许一个线程进入，其他线程只能等往此临界区被释放后才能进入，否则只能等待，线程也将挂起。需要注意的是临界区在同一线程中可以重复连续的多次进入，它并不像...
Windows几种线程同步方法介绍
01-09
线程之间需要通信，如A线程霸占某个B线程需要的资源X，在A占用期间，B线程只能等待，或处于挂起状态，当A线程用完资源X后，系统会告诉线程B，资源X可以用了，或是将处于挂起状态的线程B唤醒，然后线程B获得对资源X的...
【JAVA开源】基于Vue和SpringBoot的高校学科竞赛平台
杨荧的CSDN博客
10-10 1442
教师功能有个人中心，题目类型管理，竞赛题库管理，竞赛类型管理，竞赛信息管理，报名信息管理，竞赛评分管理，参赛名单管理，晋级名单管理，获奖名单管理，竞赛总结管理，报销清单管理，成绩申诉管理，参赛信息管理，参赛信息管理，往年成绩管理，获奖情况管理。
Puppeteer自动化：使用JavaScript定制PDF下载
ip16yun的博客
10-08 915
Puppeteer 是一个强大的Node.js库，提供了对无头Chrome或Chromium的控制，可以用于生成网页快照、抓取数据、自动化测试等任务。其中，生成PDF文件是一个常见的需求，本文将通过使用Puppeteer展示如何自动化生成定制的PDF，并使用代理IP、设置user-agent、cookie等技术来增强自动化过程的灵活性与稳定性。为了更好地理解如何定制Puppeteer生成的PDF文件，我们提供一个生成A4纸张格式的网页PDF的实例。用户可以根据需求自定义输出的PDF格式或内容。
Netty 相比原生IO模型的优势
lssffy的博客
10-09 655
Java提供了多种I/O模型，每种模型都有其适用的场景和特点，随着网络应用需求的变化，I/O模型也在不断发展。阻塞I/O（BIO，Blocking I/O）传统的I/O模型，使用简单，但每次I/O操作都会阻塞线程。每个请求需要独立的线程来处理，这在并发请求较少时问题不大，但在高并发情况下，线程资源将成为瓶颈。非阻塞I/O（NIO，Non-Blocking I/O）引入了多路复用技术，一个线程可以处理多个连接，避免了BIO中每个连接占用一个线程的问题。通过Selector。
JavaSE——认识异常
最新发布
wx2023_10_15的博客
10-12 941
本文主要是正在学习异常的总结，主要讲了异常的概念、体系结构、分类、处理以及捕获，还有自定义异常类
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值