java并发编程总结一（待补充）

最新推荐文章于 2021-10-18 11:24:13 发布
最新推荐文章于 2021-10-18 11:24:13 发布
阅读量147 收藏
点赞数
分类专栏： java_concurrent
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42156928/article/details/90813400
版权

文章目录

synchronized关键字

对某个对象进行加锁
使用synchronized关键字有以下三种使用方式：

  1. 同步代码块
    同步代码块锁的是括号里面的配置对象
  2. 同步方法
    同步方法锁的是当前实例对象
  3. 静态同步方法
    静态同步方法锁的是当前类的Class对象
  • 自己新建一个对象作为锁住的对象
public class T{
	private int count = 10;
	private Object o =new Object();
	public void m(){
		synchronized(o){
			count--;
			System.out.println(Thtread.currentThread().getName() + "count = " + count);
		}
	}
}
  • 使用this对象作为锁对象

public class T{
	private int count = 10;
	public void m(){
		synchronized(this){//同步代码块
			count--;
			System.out.println(Thtread.currentThread().getName() + "count = " + count);
		}
	}
}
  • 上文代码的另外一种写法
public class T{
	private int count = 10;
	public synchronized void m(){//同步方法
		count--;
		System.out.println(Thtread.currentThread().getName() + "count = " + count);
	}
}
  • 静态同步方法：没有this对象的静态方法如何获得锁对象
public class T{
	private int count = 10;
	public synchronized void m(){
		count--;
		System.out.println(Thtread.currentThread().getName() + "count = " + count);
	}
	public static void mm(){
		synchronized(T.class){//静态的方法没有this对象，所以用反射来获取它的锁对象
			count--;
		}
	}
}

public class T implements Runnable{
	private int count = 10;
	public /*synchronized*/ void run(){//synchronized所标注的代码块具备原子性，执行期间不可再分
		count--;
		System.out.println(Thtread.currentThread().getName() + "count = " + count);
	}
	public void main(){
		T t = new T();//只有一个对象
		for(int i = 0; i < 5; i++){
			new Thread(t, "THREAD" + i).start();//开启五个线程，共同访问t对象，共同访问count
		}
	}
}
同步方法和非同步方法是否可以同时被调用

在一个同步方法执行的过程中，非同步的方法可以运行，因为非同步方法的执行不需要锁

public class demo6 {
	public synchronized void m1() {
		System.out.println(Thread.currentThread().getName() + "m1 start.... ");
		try {
			Thread.sleep(10000);
		}catch(InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println(Thread.currentThread().getName() + "m1 end.... ");
		
	}
	
	public void m2() {
		try {
			Thread.sleep(5000);
		}catch(InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println(Thread.currentThread().getName() + "m2 .... ");
	}
	
	public static void main(String[] args) {
		demo6 t = new demo6();
		
		new Thread(()->t.m1(), "t1").start();
		new Thread(()->t.m2(), "t2").start();

	}
}
脏读

写时需要加锁，读时其实也需要加锁，否则容易出现脏读的现象

/*写的时候加锁
 * 读的时候不加锁
 * 脏读的现象
 */
package concurrent1;
import java.util.concurrent.TimeUnit;
public class demo8 {
	String name;
	double balance;
	
	public synchronized void set(String name, double balance) {
		this.name = name;
		
		try {
			Thread.sleep(2000);
		}catch (InterruptedException e) {
			// TODO: handle exception
			e.printStackTrace();
		}
		
		this.balance = balance;
	}
	
	public double getBalance(String name) {
		return this.balance;
	}
	
	public static void main(String[] args) {
		demo8 aDemo8 = new demo8();
		
		new Thread(()->aDemo8.set("zhangsan", 100.0)).start();
		
		try {
			TimeUnit.SECONDS.sleep(1);
		}catch (InterruptedException e) {
			// TODO: handle exception
			e.printStackTrace();
		}
		
		System.out.println(aDemo8.getBalance("zhangsan"));
		
		try {
			TimeUnit.SECONDS.sleep(2);
		}catch (InterruptedException e) {
			// TODO: handle exception
			e.printStackTrace();
		}
		System.out.println(aDemo8.getBalance("zhangsan"));
	}
}
可重入
import java.util.concurrent.TimeUnit;

/*
 * 一个同步方法是否可以调用另外一个同步的方法
 * 一个已经拥有某个对象锁的线程，再次申请的时候仍然会得到该对象的锁
 * 即：synchronized获得的锁是可以重入的
 */
public class demo9 {
	synchronized void m1() {
		System.out.println("m1 start...");
		try {
			TimeUnit.SECONDS.sleep(1);
		}catch (InterruptedException e) {
			// TODO: handle exception
			e.printStackTrace();
		}
		m2();
	}
	
	synchronized void m2() {
		try {
			TimeUnit.SECONDS.sleep(2);
		} catch (InterruptedException e) {
			// TODO: handle exception
			e.printStackTrace();
		}
		System.out.println("m2");
	}
}
  • 子类中调用父类的同步方法
//子类中调用父类的同步方法
import java.util.concurrent.TimeUnit;

public class demo10 {
	synchronized void m() {
		System.out.println("m start  ..");
		try {
			TimeUnit.SECONDS.sleep(1);
		}catch (InterruptedException e) {
			// TODO: handle exception
			e.printStackTrace();
		}
		System.out.println("m end");
	}
	
	public static void main(String[] args) {
		new TT().m();
	}
}

class TT extends demo10{
	@Override
	synchronized void m() {
		System.out.println("child m start");
		super.m();
		System.out.println("child m end");
	}
}
程序在执行过程中出现异常，锁会被释放
import java.sql.Time;
import java.util.concurrent.TimeUnit;

/*
 * 程序在执行时，如果出现异常，默认情况下锁会被释放，这时其他的线程访问的数据可能会出现不一致的情况
 */
public class T {
	int count = 0;
	synchronized void m() {
		System.out.println(Thread.currentThread().getName() + "  start ");
		while(true) {
			count++;
			System.out.println(Thread.currentThread().getName() + "count = " + count);
			try {
				TimeUnit.SECONDS.sleep(1);
			}catch (InterruptedException e) {
				// TODO: handle exception
				e.printStackTrace();
			}
			
			if(count == 5) {
				int i = 1/0;
			}
		}
	}
	
	public static void main(String[] args) {
		T t =new T();
		
		Runnable r = new Runnable() {
			
			@Override
			public void run() {
				// TODO Auto-generated method stub
				t.m();
			}
		};
		try {
			TimeUnit.SECONDS.sleep(2);
		} catch (InterruptedException e) {
			// TODO: handle exception
			e.printStackTrace();			
		}
		new Thread(r, "t2").start();
	}
}
volatile 关键字：内存可见性

使一个变量在多个线程间可见。

Java编程语言允许线程访问共享变量，为了确保共享变量能够准确一致地更新，线程确保通过排他锁单独获得这个变量。

Java中的volatile关键字就是这个定义的体现。如果一个变量被声明为volatile，那么确保这个变量是“可见的”。可见性的意思是当线程修改一个共享变量的时候，另外一个线程能够读到这个修改的值。

具体原理参见：这个

例子：

public class T {
	volatile boolean running = true;
	void m() {
		System.out.println(" m start ");
		while(running) {
			
		}
		System.out.println("m end ...");
	}
	
	public static void main(String[] args) {
		T t =new T();
		
		new Thread(t::m, "t1").start();
		try {
			TimeUnit.SECONDS.sleep(2);
		} catch (InterruptedException e) {
			// TODO: handle exception
			e.printStackTrace();			
		}
		t.running = false;
	}
}
volatile 与synchronized的区别：

volatile只能保证可见性
synchronized既保证可见性又保证了原子性

public class T {
	volatile int count = 0;//只保证可见性
	void m() {
		for(int i = 0; i < 10000; i++) count++;
	}
	
	public static void main(String[] args) {
		T t =new T();
		
		List<Thread> threads = new ArrayList<Thread>();
		
		for(int i = 0; i < 10; i++)
			threads.add(new Thread(t::m, "thread-" + i));
		
		threads.forEach((o)->o.start());
		
		threads.forEach((o)->{
			try {
				o.join();
			} catch (InterruptedException e) {
				// TODO: handle exception
				e.printStackTrace();
			}
		});
		
		System.out.println(t.count);
	}
}
使用Atomic***类来保证原子性
public class T {
	AtomicInteger count = new AtomicInteger(0);
	void m() {
		for(int i = 0; i < 10000; i++){
//			if(count.get() < 1000)  //使用Atomicxxx的多个方法并不具备原子性
			count.incrementAndGet();//用于替代count++的
		}
	}
	
	public static void main(String[] args) {
		T t = new T();
		
		List<Thread> threads = new ArrayList<Thread>();
		
		for (int i = 0; i < 10; i++) {
			threads.add(new Thread(t::m, "thread-" + i));
		}
		
		threads.forEach((o) -> o.start());
		
		threads.forEach((o) -> {
			try {
				o.join();
			} catch (InterruptedException e) {
				// TODO: handle exception
				e.printStackTrace();
			}
		});
		System.out.println(t.count);
	}
	
}
synchronized的优化
public class T {
	int count = 0;
	synchronized void m1() {
		try {
			TimeUnit.SECONDS.sleep(2);
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		}
		
		count++;
		
		try {
			TimeUnit.SECONDS.sleep(2);
		} catch (InterruptedException e) {
			// TODO: handle exception
			e.printStackTrace();
		}
	}
	
	void m2() {
		try {
			TimeUnit.SECONDS.sleep(2);
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		}
		//业务逻辑中只有下面的这句话需要同步，这时不应该在给整个方法加上锁
		//采用更加细粒度的方法，可以使线程争用的时间变短，提高效率
		synchronized (this) {
			count++;
		}
		
		try {
			TimeUnit.SECONDS.sleep(2);
		} catch (InterruptedException e) {
			// TODO: handle exception
			e.printStackTrace();
		}
	}	
}
锁住的对象属性发生改变不会影响锁的使用，但是如果引用的对象改变情况就大为不同了
public class T {
	Object o = new Object();
	
	void m() {
		synchronized (o) {
			while(true) {
				try {
					TimeUnit.SECONDS.sleep(1);
				} catch (Exception e) {
					// TODO: handle exception
					e.printStackTrace();
				}
				System.out.println(Thread.currentThread().getName());
			}
		}
	}
	
	public static void main(String[] args) {
		T t = new T();
		
		new Thread(t::m, "t1").start();
		
		try {
			TimeUnit.SECONDS.sleep(3);
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		}
		
		Thread t2 = new Thread(t::m, "t2");
		
		t.o = new Object();
		
		t2.start();
	}
}
不应该用字符串作为锁定的对象
public class T {

	String s1 = "Hello";
	String s2 = "Hello";
	
	void m1() {
		synchronized (s1) {
			
		}
	}
	
	void m2() {
		synchronized (s2) {
			
		}
	}
}
cook_1996
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java并发编程基础（一篇入门）
行者无疆的博客
03-09 5157
1 并发编程简介 1.1 什么是并发编程 所谓并发编程是指在一台处理器上 “同时” 处理多个任务。并发是在同一实体上的多个事件。多个事件在同一时间间隔发生。 并发编程，从程序设计的角度来说，是希望通过某些机制让计算机可以在一个时间段内，执行多个任务。从计算机 CPU 硬件层面来说，是一个或多个物理 CPU 在多个程序之间多路复用，提高对计算机资源的利用率。从调度算法角度来说，当任务数量多于 CPU 的核数时，并发编程能够通过操作系统的任务调度算法，实现多个任务一起执行。 1.2 并发编程的重要性 对于一个
并发编程（java）
randomswap的博客
07-17 109
并发编程三大特性 可见性（visibility） 有序性 (ordering) 原子性（atomicity) 可见性： 首先看一个小程序 public class T01 { private static boolean running = true; private static void m(){ System.out.println("m start"); while (running){ System.out.pr
Java并发编程的艺术
qq_36811160的博客
07-19 1756
Java并发编程的艺术读书笔记
Java的并发编程涉及到知识点总结
qq_41510985的博客
10-16 1078
Java的并发编程涉及到知识点总结一、JMM模型二、volatile关键字三、synchronized原理详解四、AQS五、BlockingQueue六、 Semaphore七、CountDownLatch八、CyclicBarrier九、Atomic十、Unsafe十一、HashMap十二、ConcurrentHashMap十三、线程池概念十四、线程池—ThreadPoolExecutor十五、定时线程池—ScheduledThreadPoolExecutor十六、什么是 Fork/Join 框架？十七、
JAVA并发编程
qq_43060411的博客
10-18 9308
并发编程 1.进程与线程 程序由指令和数据组成，但这些指令要运行，数据要读写，就必须将指令加载至 CPU，数据加载至内存。在 指令运行过程中还需要用到磁盘、网络等设备。进程就是用来加载指令、管理内存、管理 IO 的。 当一个程序被运行，从磁盘加载这个程序的代码至内存，这时就开启了一个进程。 进程就可以视为程序的一个实例。大部分程序可以同时运行多个实例进程（例如记事本、画图、浏览器 等），也有的程序只能启动一个实例进程（例如网易云音乐、360 安全卫士等） ...
java并发编程实战源码-JavaConcurrentProgramming:《Java并发编程实战》
05-25
《Java并发编程实战》是Java开发者深入理解并发编程的一本经典著作。这本书涵盖了Java多线程和并发库的广泛主题，旨在帮助读者掌握如何在Java环境中有效地设计和实现并发程序。源码JavaConcurrentProgramming-master...
JAVA并发编程实战JAVA并发编程实战JAVA并发编程实战JAVA并发编程实战
08-30
《Nginx高性能Web服务器详解》可能是与Java并发编程实战相关的补充阅读，因为Nginx作为一个高性能的反向代理服务器，经常与Java应用服务器配合使用，优化Web服务的并发处理能力。Nginx的异步非阻塞I/O模型和事件驱动...
java7并发编程实战手册+源码
06-14
本书涵盖了从基本概念到高级特性的全方位知识，是提升Java并发编程能力的不二之选。 在Java中，多线程是并发编程的基础，它允许程序同时执行多个任务，从而提高系统的利用率和性能。Java 7在并发方面引入了许多改进...
java函数编程
02-12
Java函数编程是Java语言的一种现代编程范式，它引入了函数式编程的概念，使得Java开发者可以采用更加简洁、声明式的编程风格。在Java 8及更高版本中，函数编程得到了显著增强，为开发者提供了丰富的API和特性来实现...
java网络编程.zip
05-12
Java网络编程是软件开发中的重要领域，特别是在分布式系统和互联网应用中不可或缺。北邮的这组计算机网络编程课件...这是一份全面而实用的学习资源，对于想要在Java网络编程领域深化的人来说，无疑是一份宝贵的财富。
volatile关键字的功能和底层实现原理
weixin_42156928的博客
06-20 4404
文章目录功能1：变量内存间的可见性1. 概述2. 底层原理功能2： 禁止指令重排序1.概念2. 指令重排序可能会带来的问题3. 禁止指令重排的原理事例待续。。。 功能1：变量内存间的可见性 1. 概述 如果一个变量被volatile关键字修饰，那么所有线程都是可见的。所谓可见就是，当一条线程修改了这个变量值，新值对于其他线程来时是立即可见的; 而普通变量不能做到这一点。 对于普通的变量： 普通变...
java并发编程面试题2.生产者消费者模式
weixin_42156928的博客
06-08 292
面试题：生产者消费者模式 写一个固定容量的同步容器，拥有put和get方法，以及getCount方法 能够支持两个生产者线程以及十个消费者线程的阻塞调用 方法一：使用wait和notify来调用 public class MyContainer2<T> { final private LinkedList<T> lists = new LinkedList<...
java并发编程面试题1
weixin_42156928的博客
06-05 156
实现一个容器，提供两个方法add和size 写两个线程，线程1添加十个元素到容器中，线程2实现监控元素的个数，当个数达到五个时线程2 给出提示并结束 方法一：volatile关键字 public class MyContainer1 { volatile List list = new ArrayList(); public void add(Object o) { list.ad...
多线程下的单例设计模式
weixin_42156928的博客
06-09 129
方法一： public class Singleton1 { /* */ private static Singleton1 singleton = new Singleton1();//直接初始化一个实例对象 private Singleton1() {//私有构造函数，保证其他对象不能够直接new出该对象的一个实例 } public static Singleton...
java并发编程总结三ThreadLocal（待补充）
weixin_42156928的博客
06-09 103
ThreadLocal一般称为线程本地变量，它是一种特殊的线程绑定机制，将变量与线程绑定在一起，为每一个线程维护一个独立的变量副本。通过ThreadLocal可以将对象的可见范围限制在同一个线程内。 举个栗子：一个线程中更改了名字，另外一个线程立即能够看到 public class ThreadLocal1 { volatile static Person p = new Person();...
java并发编程总结二ReentrantLock
weixin_42156928的博客
06-08 90
1. 使用ReentrantLock来替代synchronized 需要注意的是，使用reentrantLock必须手工释放锁 使用synchronized锁如果出现异常的话，jvm会自动释放锁，但是lock必须手工释放，可以在finally代码块中释放 public class ReentrantLock2 { Lock lock = new ReentrantLock(); voi...
GDAL-2.4.1-cp36-cp36m-win_amd64.whl
最新发布
07-17
GDAL-2.4.1-cp36-cp36m-win_amd64.whl
注射用七叶皂苷钠说明书.doc
07-17
说明书
并发大神DougLea文章集锦
09-19
并发大神DougLea文章集锦

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值