Java线程（二） 线程同步

最新推荐文章于 2024-09-13 17:30:19 发布
最新推荐文章于 2024-09-13 17:30:19 发布
阅读量210 收藏 1
点赞数 1
分类专栏： 线程同步 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010184528/article/details/105454287
版权

目录

synchronized基础概念

为什么要用到线程同步

synchronized的3中实现方式：

方式1：synchronized代码块

方式2：synchronized修饰方法

方式3：synchronized修饰类

synchronized基础概念

  • 多个线程步调一致的执行；
  • 让多个线程争夺同一个对象的同步锁，任何对象都有唯一同步锁，只要创建一个对象，就会自有一个同步锁，注意，这里说的是对象，定义出来的基本类型是没有线程锁的；
  • 多个线程对同一个对象操作，谁抢到锁谁执行，抢不到就等待，这样就保证没有脏数据；

为什么要用到线程同步

先来看一个例子：比如我现在有一个1-10个数字的整型集合，我现在对集合中2对倍数的数字进行加2，反复操作1000次，在另一个集合中进行数组打印：

public class SynchornizedTest {
	
	static int nums=1000;
	static int nums2=10;
	static ArrayList<Integer>list=new ArrayList<>();
	
	public static void main(String[] args) {
		
		//集合中有1到10个数字
		for(int i=1;i<=10;i++) {
			list.add(i);
		}
		
		SynchornizedThread t1=new SynchornizedThread();
		t1.start();
		
		SynchornizedThread2 t2=new SynchornizedThread2();
		t2.start();
	}
	
	//该线程对是2的倍数的数据进行反复的加2,操作1000次
	static class SynchornizedThread extends Thread{
		@Override
		public void run() {
				while(nums>0) {
					for(int i=0;i<list.size();i++) {
						if(list.get(i)%2==0) {
							list.set(i, list.get(i)+2);
						}
					}
					nums--;
				}
		}
	}
	
	//该线程取数据，打印10次
	static class SynchornizedThread2 extends Thread{
		@Override
		public void run() {
				while(nums2>0) {
				System.out.println(list);
				nums2--;
				}
		}
	}
}

打印结果：很明显每次打印结果都是不同的，这里面就有脏数据，因为输出的话，应该输出线程1中操作完成的数据

synchronized的3中实现方式：

synchronized代码块方式2 synchronized修饰方法方式3 synchronized静态方法--属于类

synchronized(要操作的对象){

 

}

  • 争夺指定对象的锁

synchronized void f（）{

 

}

  • 争夺当前对象（this）的锁

static synchronized void f（）{

 

}

  • 相当于抢当前类的锁

方式1：synchronized代码块

测试：争夺指定对象list集合的锁

举例：对上面对例子进行线程同步

public class SynchornizedTest {
	
	static int nums=1000;
	static int nums2=10;
	static ArrayList<Integer>list=new ArrayList<>();
	
	public static void main(String[] args) {
		
		//集合中有1到10个数字
		for(int i=1;i<=10;i++) {
			list.add(i);
		}
		
		SynchornizedThread t1=new SynchornizedThread();
		t1.start();
		
		SynchornizedThread2 t2=new SynchornizedThread2();
		t2.start();
	}
	
	//该线程对是2的倍数的数据进行反复的加2,操作1000次
	static class SynchornizedThread extends Thread{
		@Override
		public void run() {
			synchronized (list) {
				while(nums>0) {
					for(int i=0;i<list.size();i++) {
						if(list.get(i)%2==0) {
							list.set(i, list.get(i)+2);
						}
					}
					nums--;
				}
			}
		}
	}
	
	//该线程取数据，打印10次
	static class SynchornizedThread2 extends Thread{
		@Override
		public void run() {
			synchronized (list) {
				while(nums2>0) {
				System.out.println(list);
				nums2--;
				}
			}
		}
	}
}

打印结果：

方式2：synchronized修饰方法

测试：争夺当前对象（this）的锁，由对象r1调用add和get两个方法，按序执行

举例：比如我现在循环中打印一个数字是否是奇数：

public class SynchornizedTest2 {

	public static void main(String[] args) {
		R1 r1=new R1();
		Thread t1=new Thread(r1);
		t1.start();
		
		//死循环检查是不是奇数
		while(true) {
			int i=r1.get();
			if(i%2==1) {
				System.out.println("出现奇数："+i);
				System.exit(0);//关闭虚拟机
			}
		}
	}
	
	static class R1 implements Runnable{
		
		static int i;
		
		public  void add() {
			i++;
			i++;
		}
		
		public  int get() {
			return i;
		}
		
		@Override
		public void run() {
			 while(true) {
				 add();
			 }
		}
	}
}

打印结果：按照上面的逻辑，其实不应该打印出奇数，因为i++应该执行两次，现在打印出来了，说明i++执行了一次就执行get方法了，这是main线程和t1线程冲突导致

  

通过给方法加锁，让t1线程拿到对应方法的锁执行完之后，再拿到另一个方法的锁，再继续执行

public class SynchornizedTest2 {

	public static void main(String[] args) {
		R1 r1=new R1();
		Thread t1=new Thread(r1);
		t1.start();
		
		//死循环检查是不是奇数
		while(true) {
			int i=r1.get();
			if(i%2==0) {
				System.out.println("出现偶数："+i);
				System.exit(0);//关闭虚拟机
			}
		}
	}
	
	static class R1 implements Runnable{
		
		static int i;
		
		public synchronized void add() {
			i++;
			i++;
		}
		
		public synchronized int get() {
			return i;
		}
		
		@Override
		public void run() {
			 while(true) {
				 add();
			 }
		}
	}
}

这时再打印数据：

方式3：synchronized修饰类

测试：相当于抢当前类的锁

举例：对上面对例子进行思考，上面是只要一个线程t1，假如我现在有2个线程，在main线程里用r2进行get，看下执行结果：

public class SynchornizedTest2 {

	public static void main(String[] args) {
		R r1=new R();
		Thread t1=new Thread(r1);
		t1.start();
		
		R r2=new R();
		
		
		//死循环检查是不是奇数
		while(true) {
			int i=r2.get();
			if(i%2==1) {
				System.out.println("出现奇数："+i);
				System.exit(0);//关闭虚拟机
			}
		}
	}
	
	static class R implements Runnable{
		
		static int i;
		
		public synchronized void add() {
			i++;
			i++;
		}
		
		public synchronized int get() {
			return i;
		}
		
		@Override
		public void run() {
			 while(true) {
				 add();
			 }
		}
	}
}

输出：依然出现里奇数，为什么呢？因为此时虽然有synchronized来对方法进行修饰，但是此时已经不是一个对象进行操作，方法2只是争夺当前对象（this）的锁；

此时对代码进行处理：

public class SynchornizedTest2 {

	public static void main(String[] args) {
		R r1=new R();
		Thread t1=new Thread(r1);
		t1.start();
		
		R r2=new R();
		
		
		//死循环检查是不是奇数
		while(true) {
			int i=r2.get();
			if(i%2==0) {
				System.out.println("出现偶数："+i);
				System.exit(0);//关闭虚拟机
			}
		}
	}
	
	static class R implements Runnable{
		
		static int i;
		
		public static synchronized void add() {
			i++;
			i++;
		}
		
		public static synchronized int get() {
			return i;
		}
		
		@Override
		public void run() {
			 while(true) {
				 add();
			 }
		}
	}
}

输出：

小小苏的小小苏
关注
专栏目录
JAVA线程同步
miqq_79872135的博客
03-23 2919
线程同步 线程同步：即当有一个线程在对内存进行操作时，其他线程都不可以对这个内存地址进行操作，直到该线程完成操作， 其他线程才能对该内存地址进行操作，而其他线程又处于等待状态，实现线程同步的方法有很多。 为什么要创建多线程？ 在一般情况下，创建一个线程是不能提高程序的执行效率的，所以要创建多个线程。 为什么要线程同步 多个线程同时运行的时候可能调用线程函数，在多个线程同时对同一个内存地址进行写入，由于CPU时间调度上的问题，写入数据会被多次的覆盖，所以就要使线程同步。 例如：我们去银行存钱，那肯定
JAVA多线程之线程同步
qq_39367410的博客
10-09 3073
线程同步、并发的基本概念以及解决问题的三种方法
Python之父吉多·范罗苏姆为什么要将这种编程语言取名“Python”
人邮异步社区
10-18 2847
正所谓“落其实者思其树，饮其流者怀其源”。当学习和使用Python的时候，同样也需要了解Python的创始人。 Python的诞生本身就注定了这个计算机编程语言会扎根于草根阶层。在1989年12月的圣诞节期间，荷兰程序员吉多·范罗苏姆（Guido van Rossum）利用空闲时间作为一个周末项目开始研究并开发一个新的脚本解释程序（即Python），并将其作为对ABC语言的一种继承。吉多·范罗苏...
Java线程的6种状态及切换(透彻讲解)
程序袁小黑
07-05 770
Java中的线程的状态分为6种。 初始(NEW)：新创建了一个线程对象，但还没有调用start()方法。 运行(RUNNABLE)：Java线程中将就绪（ready）和运行中（running）两种状态笼统的成为“运行”。 线程对象创建后，其他线程(比如main线程）调用了该对象的start()方法。该状态的线程位于可运行线程池中，等待被线程调度选中，获取cpu 的使用权，此时处于就绪状态（r...
java多线程抢占资源_java 多线程争抢资源死锁
weixin_29027305的博客
02-13 909
多线程争抢资源死锁的原理就是，A线程正在持有锁1却想获取锁2，B线程正在持有锁2却要获取锁1代码如下：public class Main {static ReentrantLock lock1 = new ReentrantLock();static ReentrantLock lock2 = new ReentrantLock();static class Test1 implements Ru...
Java多线程——线程同步
u010759175的专栏
12-28 2960
1.不安全的买票 //不安全的买票 //线程不安全，有负数或者多人买到同一张票 public class UnsafeBuyTicket { public static void main(String[] args) { BuyTicket buyTicket = new BuyTicket(); new Thread(buyTicket,"苦逼的我").start(); new Thread(buyTicket,"牛逼的你们").start(); new Thread(buyTic
java 同步线程方式
延成的博客
05-19 2942
Java并发编程包含三个基本概念: 原子性：一（多）个操作要么全部执行要么不执行，中途不会被打断； 可见性：一个线程对某变量的修改对其他线程来说是可见的，即能知道值进行过修改； 有序性：程序执行按照代码的顺序执行； 1.同步方法 使用synchronized关键字 public static void main(String[] args){ Increase increase = new Increase(); int count = 10; whil
Java多线程 - 线程同步
honvin的博客
09-22 3955
线程同步，主要是应用在多个线程操作同一个资源。 并发：同一个对象被多个线程同时操作。 例子： 上万人同时抢100张票 一个账号在两个银行同时取钱 现实生活中，并发情况很常见。比如，食堂排队打饭，每个人都想吃饭，最天然的解决办法就是排队，一个个来。 处理多线程问题时，多个线程访问同一个对象，并且某些线程还想修改这个对象这时候我们就需要线程同步。线程同步其实就是一种等待机制，多个需要同时访问，此对象的线程进入这个对象的等待池形成队列，等待前面线程使用完毕，下一个线程再使用。 排队的形成条件：队列 + 锁 由
Java多线程超详解
热门推荐
weixin_44797490的博客
06-11 14万+
引言 随着计算机的配置越来越高，我们需要将进程进一步优化，细分为线程，充分提高图形化界面的多线程的开发。这就要求对线程的掌握很彻底。 那么话不多说，今天本帅将记录自己线程的学习。 线程的相关API //获取当前线程的名字 Thread.currentThread().getName() 1.start():1.启动当前线程2.调用线程中的run方法 2.run():通常需要重写Thread类中的此...
Java synchronized关键字实现线程同步
WYSCODER的博客
04-02 6265
synchronized关键字实现线程同步
java 实现线程同步的方式有哪些
09-05
Java中的线程同步是解决多线程环境下并发访问共享数据可能导致的数据不一致性问题的关键技术。在Java中，有多种方式可以实现线程同步，确保在任何时刻只有一个线程能够访问特定的共享资源。 1. **同步代码块 ...
java线程同步操作实例详解
08-27
Java线程同步操作实例详解 Java线程同步操作是指在多线程编程中，为了避免线程之间的数据不一致和混乱，采取的一种机制，以确保线程安全。Java提供了多种方式来实现线程同步，包括synchronized关键字、Lock接口、...
Java线程间同步互斥
03-17
Java线程间同步互斥，在实际的编程中，经常要处理线程间的同步互斥问题。Java 语言内在强大的多线程支持使得处理这类问题变得相对来说比较简单。本例将模仿经典的线程同步互斥例子——生产者和消费者问题，来演示 　...
Java多线程-同步机制解决线程安全问题方式二：同步方法
01-30
为了确保并发执行的线程能够正确地处理这些共享资源，Java提供了多种同步机制，其中之一就是同步方法。同步方法通过在方法前加上`synchronized`关键字来实现，确保同一时间只有一个线程可以执行该方法。 一、同步...
详解java多线程的同步控制
01-20
同步控制是并发程序必不可少的重要手段，本文我们将通过重入锁、读写锁、信号量、倒计数器和循环栅栏以及他们的实例来介绍Java并发程序中的同步控制。 目录线程安全 Thread Safety重入锁 ReentrantLock读写锁 ...
spring事务详细讲解-深入浅出
小电玩
09-08 516
Spring 事务是本身就是对数据库的事务的支持，没有数据库的事务 Spring 是本身无法实现事务的。Spring只提供了统一事务管理接口，具体的实现还是由各数据库自己实现。在使用 Spring 事务时，可以通过注解或编程方式将需要进行事务管理的方法和代码块标记为事务性操作，当这些操作被执行时，Spring 会负责开启时根据当前环境中设置的隔离级别，调整数据库隔离级别。
Java多线程：深入探索与详细解析
m0_63550220的博客
09-08 1500
作为Java中的基本执行单元，线程是轻量级的进程，由线程ID、程序计数器、Java虚拟机栈、本地方法栈、和线程私有内存等部分组成。每个线程都有独立的执行路径，但共享进程的资源（如内存）。：进程是系统资源分配的基本单位，它包含了一个或多个线程以及这些线程运行所需的资源。在Java中，JVM（Java虚拟机）就是一个进程，而运行在JVM上的多个线程则共享JVM的内存空间。：并发指的是多个任务在同一时间段内交替执行，而并行则指的是多个任务在同一时刻真正同时执行。
自动生成不重复的订单id
最新发布
ClaireCheney的博客
09-13 122
【代码】自动生成不重复的订单id。
Java集合：Stack详解
yang_brother的博客
09-10 567
Java 中的Stack类是一个后进先出（LIFO, Last In First Out）的数据结构，它继承自Vector类。尽管Stack是一个可用的类，但它被认为是遗留的，并且在新代码中不推荐使用。通常建议使用Deque或ArrayDeque作为替代。
Java线程同步方法实战解析
"Java线程同步方法实例总结，包括Semaphore的使用" 在Java多线程编程中，线程同步是确保多个线程安全共享数据的关键技术。本篇内容主要涉及Java线程同步的方法，通过实例深入解析并发控制的实现。 1. **Semaphore...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

小小苏的小小苏

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

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

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

打赏作者

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

抵扣说明：

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

余额充值