Java高并发编程——常见问题、举例（3）

最新推荐文章于 2022-05-01 10:13:52 发布
最新推荐文章于 2022-05-01 10:13:52 发布
阅读量472 收藏 2
点赞数 1
分类专栏： java学习 文章标签： java 高并发 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a_hui_tai_lang/article/details/79528488
版权

1、深入理解synchronized关键字
synchronized锁住的是对象
　　你是怎么理解synchronized的呢？看看以下的一段代码，synchronized锁住的是花括号里面的代码吗？其实synchronized锁住的是一个对象（即以下代码的o对象）。

public class T {
	private int count = 10;
	private Object o = new Object();
	
	public void m() {
		synchronized(o) { //任何线程要执行下面的代码，必须先拿到o的锁
			count--;
			System.out.println(Thread.currentThread().getName() + " count = " + count);
		}
	}
}

再看一段代码，继续理解和体会锁住对象的含义

public class T {
	
	private int count = 10;
	
	public void m() {
		synchronized(this) { //任何线程要执行下面的代码，必须先拿到this的锁
		count--;
		System.out.println(Thread.currentThread().getName() + " count = " + count);
		}
	}
}

public class T {

	private int count = 10;
	public synchronized void m() { //等同于在方法的代码执行时要synchronized(this)
		count--;
		System.out.println(Thread.currentThread().getName() + " count = " + count);
	}
}

2、静态方法的锁

public class T {
	private static int count = 10;
	public synchronized static void m() { //这里等同于synchronized(T.class)
		count--;
		System.out.println(Thread.currentThread().getName() + " count = " + count);
	}
	
	public static void mm() {
		synchronized(T.class) { //考虑一下这里写synchronized(this)是否可以？
			count --;
		}
	}
}

考虑一下这里写synchronized(this)是否可以？答案是不可以的，不信可以用开发软件试一下，不用运行就已经提示你代码有问题。原因是静态方法一开始就加载了，而对象还没有new出来，自然也不能用synchronized关键字来锁对象，而只能锁这个类对象（T.class）。
3、线程安全问题

public class T implements Runnable {
	private int count = 10;
	public /*synchronized*/ void run() { 
		count--;
		System.out.println(Thread.currentThread().getName() + " count = " + count);
	}
	public static void main(String[] args) {
		T t = new T();
		for(int i=0; i<5; i++) {
			new Thread(t, "THREAD" + i).start();
		}
	}
}

以上代码如果没有加synchronized关键字，则有可能出现线程安全的问题，比如结果：
THREAD0 count = 9
THREAD2 count = 7
THREAD3 count = 7
THREAD1 count = 6
THREAD4 count = 5
　　自己思考一下，自然能够想明白，再看看以下代码暗藏的陷阱，猜猜结果是多少

public class T implements Runnable {
	private int count = 10;
	public synchronized void run() { 
		count--;
		System.out.println(Thread.currentThread().getName() + " count = " + count);
	}
	public static void main(String[] args) {
		
		for(int i=0; i<5; i++) {
			T t = new T();
			new Thread(t, "THREAD" + i).start();
		}
	}
}

程序输出结果为：
THREAD2 count = 9
THREAD1 count = 9
THREAD0 count = 9
THREAD4 count = 9
THREAD3 count = 9
是不是很惊喜，为什么是这个结果呢？仔细观察T t=new T()的位置即可。

4、同步和非同步方法是否可以同时调用？
当然是可以的，以下代码为证

public class T {
	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) {
		T t = new T();
		/*new Thread(()->t.m1(), "t1").start();
		new Thread(()->t.m2(), "t2").start();*/
		
		new Thread(t::m1, "t1").start();
		new Thread(t::m2, "t2").start();
	}
}

结果：
t1 m1 start…
t2 m2
t1 m1 end
　　分析：m1方法是一个同步方法（带有synchronized关键字），程序开始打印“t1 m1 start…”睡10秒钟，程序结束打印“t1 m1 end”；m2方法是一个非同步方法，睡5秒钟打印t2 m2 。两个线程同时跑，由结果可以看出，m1跑的同时，m2方法也能运行。
5、脏读现象
对业务写方法加锁
对业务读方法不加锁
容易产生脏读问题（dirtyRead）

import java.util.concurrent.TimeUnit;

public class Account {
	String name;
	double balance;
	public synchronized void set(String name, double balance) {
		this.name = name;
		try {
			Thread.sleep(2000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		this.balance = balance;
	}
	public /*synchronized*/ double getBalance() {
		return this.balance;
	}
	public static void main(String[] args) {
		Account2 a = new Account2();
		new Thread(()->a.set("zhangsan", 100.0)).start();
		try {
			TimeUnit.SECONDS.sleep(1);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println(a.getBalance());
		try {
			TimeUnit.SECONDS.sleep(2);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println(a.getBalance());
	}
}

输出结果为：
0.0
100.0
这里发生了脏读现象，如果在读方法（getBalance）处使用synchronized关键字，输出结果变为：
100.0
100.0

6、可重入锁
　　当一个线程要获取一个被其他线程占用的锁时候，该线程会被阻塞，那么当一个线程再次获取它自己已经获取的锁时候是否会被阻塞那?如果不需要阻塞那么我们说该锁是可重入锁，也就是说只要该线程获取了该锁，那么可以无限制次数进入被该锁锁住的代码。

先看一个例子如果锁不是可重入的，看看会出现什么问题。

public class Hello{
     public Synchronized void helloA(){
        System.out.println("hello");
     }

     public Synchronized void helloB(){
        System.out.println("hello B");
        helloA();
     }

}

如上面代码当调用helloB函数前会先获取内置锁，然后打印输出，然后调用helloA方法，调用前会先去获取内置锁，如果内置锁不是可重入的那么该调用就会导致死锁了，因为线程持有并等待了锁。

实际上内部锁是可重入锁，例如synchronized关键字管理的方法，可重入锁的原理是在锁内部维护了一个线程标示，标示该锁目前被那个线程占用，然后关联一个计数器，一开始计数器值为0，说明该锁没有被任何线程占用，当一个线程获取了该锁，计数器会变成1，其他线程在获取该锁时候发现锁的所有者不是自己所以被阻塞，但是当获取该锁的线程再次获取锁时候发现锁拥有者是自己会把计数器值+1， 当释放锁后计数器会-1，当计数器为0时候，锁里面的线程标示重置为null,这时候阻塞的线程会获取被唤醒来获取该锁。
　　再看一段代码

import java.util.concurrent.TimeUnit;

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

class TT extends T {
	@Override
	synchronized void m() {
		System.out.println("child m start");
		super.m();
		System.out.println("child m end");
	}
}

一个同步方法可以调用另外一个同步方法，一个线程已经拥有某个对象的锁，再次申请的时候仍然会得到该对象的锁。也就是说synchronized获得的锁是可重入的这里是继承中有可能发生的情形，子类调用父类的同步方法
7、释放锁
　　程序在执行过程中，如果出现异常，默认情况锁会被释放。所以，在并发处理的过程中，有异常要多加小心，不然可能会发生不一致的情况。比如，在一个web app处理过程中，多个servlet线程共同访问同一个资源，这时如果异常处理不合适，在第一个线程中抛出异常，其他线程就会进入同步代码区，有可能会访问到异常产生时的数据。因此要非常小心的处理同步业务逻辑中的异常


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) {
				e.printStackTrace();
			}
			if(count == 5) {
				int i = 1/0; //此处抛出异常，锁将被释放，要想不被释放，可以在这里进行catch，然后让循环继续
			}
		}
	}
	
	public static void main(String[] args) {
		T t = new T();
		Runnable r = new Runnable() {

			@Override
			public void run() {
				t.m();
			}
		};
		new Thread(r, "t1").start();
		try {
			TimeUnit.SECONDS.sleep(3);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		new Thread(r, "t2").start();
	}
}

输出结果：
t1 start
t1 count = 1
t1 count = 2
t1 count = 3
t1 count = 4
t1 count = 5
t2 start
t2 count = 6
Exception in thread “t1” java.lang.ArithmeticException: / by zero
at yxxy.c_011.T.m(T.java:28)
at yxxy.c_011.T$1.run(T.java:39)
at java.lang.Thread.run(Thread.java:745)
t2 count = 7
t2 count = 8
…
　　分析：m()方法是同步方法，作用是不停的输出1，2，3…，当count=5时，会抛一个异常。一开始，第一个线程t1启动，打印，由于m()方法是个同步方法，synchronized上锁，锁住t对象，t2线程阻塞等待直到t对象的锁释放掉；当count=5时，抛出异常，t1线程挂了，锁被释放掉了，t2线程就启动了，由此得到了打印结果。
8、volatile关键字
　　 volatile 关键字，使一个变量在多个线程间可见， A B线程都用到一个变量，java默认是A线程中保留一份copy，这样如果B线程修改了该变量，则A线程未必知道。使用volatile关键字，会让所有线程都会读到变量的修改值。
　　在下面的代码中，running是存在于堆内存的t对象中。当线程t1开始运行的时候，会把running值从内存中读到t1线程的工作区，在运行过程中直接使用这个copy，并不会每次都去读取堆内存，这样，当主线程修running的值之后，t1线程感知不到，所以不会停止运行。使用volatile，将会强制所有线程都去堆内存中读取running的值。
　可以阅读这篇文章进行更深入的理解http://www.cnblogs.com/nexiyi/p/java_memory_model_and_thread.html
　　volatile并不能保证多个线程共同修改running变量时所带来的不一致问题，也就是说volatile不能替代synchronized

import java.util.concurrent.TimeUnit;

public class T {
	/*volatile*/ boolean running = true; //对比一下有无volatile的情况下，整个程序运行结果的区别
	void m() {
		System.out.println("m start");
		while(running) {
			/*
			try {
				TimeUnit.MILLISECONDS.sleep(10);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}*/
		}
		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(1);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		t.running = false;
	}
}

如果没有volatile关键字的话，输出结果应该是只有m start，然后程序就进入一个什么也不做的死循环；如果有volatile的话，输出结果应该是
m start
m end!
　　因为volatile保证了数据的可见性，但是这个程序自己运行的时候，不管有没有volatile关键字，都是上面的结果，我也不知道是怎么回事，难道是jvm和以前的不一样了？
9、volatile并不能保证多个线程共同修改running变量时所带来的不一致问题，也就是说volatile不能替代synchronized，运行下面的程序，并分析结果

import java.util.ArrayList;
import java.util.List;

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) {
				e.printStackTrace();
			}
		});
		System.out.println(t.count);
	}
}

输出的结果是一个随机的数字
对比上一个程序，可以用synchronized解决，synchronized可以保证可见性和原子性，volatile只能保证可见性

import java.util.ArrayList;
import java.util.List;

public class T {
	/*volatile*/ int count = 0;
	synchronized 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) {
				e.printStackTrace();
			}
		});
		System.out.println(t.count);
	}
}

输出结果为100000
　　这两个例子充分说明了synchronized可以保证可见性和原子性，volatile只能保证可见性
10、原子性
　　解决同样的问题的更高效的方法，使用AtomXXX类，AtomXXX类本身方法都是原子性的，但不能保证多个方法连续调用是原子性的

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;

public class T {
	/*volatile*/ //int count = 0;
	
	AtomicInteger count = new AtomicInteger(0); 

	/*synchronized*/ void m() { 
		for (int i = 0; i < 10000; i++)
			//if count.get() < 1000
			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) {
				e.printStackTrace();
			}
		});
		System.out.println(t.count);
	}
}

输出结果：100000
　　分析的话，原子性嘛，很好理解
11、synchronized优化

import java.util.concurrent.TimeUnit;
public class T {
	int count = 0;
	synchronized void m1() {
		//do sth need not sync
		try {
			TimeUnit.SECONDS.sleep(2);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		//业务逻辑中只有下面这句需要sync，这时不应该给整个方法上锁
		count ++;
		//do sth need not sync
		try {
			TimeUnit.SECONDS.sleep(2);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
	
	void m2() {
		//do sth need not sync
		try {
			TimeUnit.SECONDS.sleep(2);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		//业务逻辑中只有下面这句需要sync，这时不应该给整个方法上锁
		//采用细粒度的锁，可以使线程争用时间变短，从而提高效率
		synchronized(this) {
			count ++;
		}
		//do sth need not sync
		try {
			TimeUnit.SECONDS.sleep(2);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}

12、避免将锁定对象的引用变成另外的对象

import java.util.concurrent.TimeUnit;

public class T {
	Object o = new Object();
	void m() {
		synchronized(o) {
			while(true) {
				try {
					TimeUnit.SECONDS.sleep(1);
				} catch (InterruptedException e) {
					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 (InterruptedException e) {
			e.printStackTrace();
		}
		//创建第二个线程
		Thread t2 = new Thread(t::m, "t2");
		t.o = new Object(); //锁对象发生改变，所以t2线程得以执行，如果注释掉这句话，线程2将永远得不到执行机会
		t2.start();
		
	}
}

输出结果为：
t1
t1
t1
t1
t2
t1
13、不要以字符串常量作为锁定对象
　　 在下面的例子中，m1和m2其实锁定的是同一个对象，这种情况还会发生比较诡异的现象，比如你用到了一个类库，在该类库中代码锁定了字符串“Hello”，但是你读不到源码，所以你在自己的代码中也锁定了"Hello",这时候就有可能发生非常诡异的死锁阻塞，因为你的程序和你用到的类库不经意间使用了同一把锁

public class T {
	
	String s1 = "Hello";
	String s2 = "Hello";

	void m1() {
		synchronized(s1) {
			
		}
	}
	
	void m2() {
		synchronized(s2) {
			
		}
	}
	
}

我的GitHub
QQ：2541692705
邮箱：loyalwilliams@163.com
微信扫一扫关注我，没事可以玩玩小游戏



我想去流浪，我想去读书，若有机会，江湖再见
扫一扫，领取红包，就当奖励你我付出的努力

大灰狼学编程
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java高并发编程——常见问题、举例（4）
a_hui_tai_lang的博客
08-27 167
14、一道面试题引发的思考 曾经的面试题：（淘宝？） 实现一个容器，提供两个方法，add，size 写两个线程，线程1添加10个元素到容器中，线程2实现监控元素的个数，当个数到5个时，线程2给出提示并结束 14.1分析下面这个程序，能完成这个功能吗？ import java.util.ArrayList; import java.util.List; import java.ut...
并发编程常见问题总结(持续更新...).pdf
07-06
这是本人自己总结的关于在Java面试中一些常见的并发编程问题。免费分享给大家，希望对你们有用。如果有写的不对的地方，敬请大佬斧正！
一个简单的Java单例示例谈谈并发
程序猿开发日志【学习永无止境】
05-11 4136
一个简单的单例示例 单例模式可能是大家经常接触和使用的一个设计模式，你可能会这么写 public class UnsafeLazyInitiallization { private static UnsafeLazyInitiallization instance; private UnsafeLazyInitiallization() { } pub
[架构]--高并发问题及解决方案
weixin_33795806的博客
07-23 132
2019独角兽企业重金招聘Python工程师标准>>> ...
Java并发编程-常见问题
denglu2912的博客
04-14 207
一、常见问题 　　从小的方面讲， 并发编程最常见的问题就是可见性、原子性和有序性问题。 　　从大的方面讲， 并发编程最常见的问题就是安全性问题、活跃性问题和性能问题。 　　下面主要从微观上分析问题。 二、可见性问题 　　可见性：一个线程对共享变量的修改，另外一个线程能够立马看到，这个称之为可见性。知道了可见性那么你就知道可见性问题了. 　　可见性问题：一个线程对共享变量的修改...
Java异常处理-异常处理概述与常见异常举例
最新发布
01-09
在Java编程中，异常是指程序运行时遇到的问题，比如用户输入的数据格式错误、尝试打开不存在的文件或进行除零操作等。这些异常不同于语法错误（编译时不通过）和逻辑错误（程序结果不符合预期），它们会导致程序非...
Java 并发常见知识点&面试题总结
08-19
Java并发编程是Java开发者必须掌握的核心技能之一，它涉及到多线程、同步机制、线程池等关键概念。本文将深入探讨Java并发中的常见知识点，并结合面试题进行解析。 1. **线程与进程** - 线程是程序执行的最小单位...
java编程面试题包含答案
07-17
为了在面试中脱颖而出，了解并掌握Java编程面试中的常见问题及其答案至关重要。以下是一些可能出现在Java面试中的关键知识点，以及相关的解答。 1. **基本语法与数据类型** - Java有哪些数据类型？如何区分它们？ ...
举例解析Java多线程编程中需要注意的一些关键点
09-03
Java多线程编程是Java开发中的一项重要技术，它允许程序同时执行多个任务，提高了系统效率和响应速度。然而，多线程环境下的编程也带来了一些挑战，如数据同步、线程安全等问题。本文将重点讨论Java多线程编程中需要...
华中数控车床编程举例说明.doc
12-01
3. 编程举例：O0004、O0005、O0006 手册中提供了多个编程举例，如O0004、O0005、O0006等。这些举例展示了数控车床编程的各种技术，如圆弧 interpolation、helical interpolation、circular pocket milling等。 4. ...
Java 并发基础常见面试题总结
weixin_30258901的博客
05-15 2134
1. 什么是线程和进程? 1.1. 何为进程? 进程是程序的一次执行过程，是系统运行程序的基本单位，因此进程是动态的。系统运行一个程序即是一个进程从创建，运行到消亡的过程。 在 Java 中，当我们启动 main 函数时其实就是启动了一个 JVM 的进程，而 main 函数所在的线程就是这个进程中的一个线程，也称主线程。 如下图所示，在 windows 中通过查看任务管理器的方式，我们就可...
「Java并发编程」常见基础问题整理
weixin_50205273的博客
09-19 141
进程和线程？ 进程？ 进程是程序的一次执行过程，是系统运行程序的基本单位，进程是动态的。 系统运行一个程序就是一个进程从创建，运行到消亡的过程。 Java中，启动main函数的时候其实就是启动了一个JVM进程，而main函数所在的线程就是这个进程的主线程。 线程？ 线程是一个比进程更小的执行单位。 一个进程在其执行过程中产生多个线程，同类的多线程共享进程的堆和方法区资源，每个线程有自己的程序计数器，虚拟机栈和本地方法栈。 系统在产生一个线程，或是各个线程之间切换工作时，负担比进程小的多，因此线
说说并发编程的常见问题
学一次的博客
05-01 237
并发编程并不是银弹，做为一种基于共享内存的并发编程，它会存在很多编程上的问题，比如：上下文切换、死锁、线程饥饿、竞争条件、Bug难以重现和定位 并发编程的目的是为了让程序运行得更快。但是，并不是启动更多的线程就能让程序最大限度地并发执行。
Java并发编程常见问题
ZCC的专栏
08-05 419
一、并发编程常见问题 并发课程知识点索引手记：http://www.imooc.com/article/24007 并发课程问题汇总：http://www.imooc.com/article/25035 面试中并发类问题的准备和学习：http://www.imooc.com/article/23969 Fork/Join框架使用及注意点：http://www.imooc.com/artic...
JAVA并发面试常见问题
qq_51443459的博客
01-09 224
1.HashMap 在面试中HashMap是问的很多的，我们来大致看一下HashMap的一些特性和考点 HashMap 的存取是没有顺序的。 KV 均允许为 NULL。 多线程情况下该类安全，可以考虑用 HashTable。 JDk8底层是数组 + 链表 + 红黑树，JDK7底层是数组 + 链表。 初始容量和装载因子是决定整个类性能的关键点，轻易不要动。 HashMap是懒汉式创建的，只有在你put数据时候才会 build。 单向链表转换为红黑树的时候会先变化为双向链表最终转换为红黑树，切记双向链表跟
并发编程的问题
你知道的越多，你不知道的越多
11-19 294
并发编程的问题 安全性问题 ​ 事实上，并不是所用的情况用多线程就一定比单线程快。多线程如果使用不当，不仅会带来严重的安全性问题，也会造成性能问题。 ​ 在JVM内存结构中，我们知道栈、程序计数器、局部变量这些是线程私有的，但是进程范围内的资源，同一个进程内的线程都会共享进程内的地址空间，那么它们会共享堆上分配的对象。当多个线程并发运行时，它们就可能会访问或者修改其他线程正在使用的变量造成严重的后果，比如我们在JMM笔记中提到的read-modify-write。那么在并发编程中，如果我们可以对要访问的资
2、并发问题举例
qq_39037116的博客
08-15 400
买票
java并发问题
weixin_38328444的博客
04-07 186
并发存在的问题: 可见性：要求一个线程对变量的操作改变对另外一个线程要是可以看见的。例如：当线程1读取主内存中变量到工作内存，线程2也读取并在工作内存改变其值，返回主内存，但线程1还是默认自己工作内存中的值。 原子性：在一次或多次操作中，要么所有的操作都执行不受其他干扰，要么所有的操作都不执行。 有序性：程序中代码的执行顺序，java编译和执行时会对代码进行优化，可能执行顺序与我们编写顺序不一致 java内存模型： 解决原子性问题：synchronized保证只有一个线程拿到锁，能够进入代码
并发理论：并发编程会遇到哪些问题？
小识的博客
02-16 497
缓存带来的可见性问题 线程切换带来的原子性问题 假设sum=0，执行如下代码 sum++ sum++其实是如下3步操作 读取sum=0 计算sum+=1 将1赋值给sum 时间 线程A 线程B t1 读取sum=0 t2 读取sum=0 t3 计算sum+1=1 t4 计算sum+1=1 t5 将1赋值给sum t6 将1赋值给sum sum被2个线程加了2次，但是值却只增加了1 编译优化带来的有序性问题 public class Singleto.
Java高并发常见面试问题
07-15
1. 什么是线程安全？如何保证Java程序的线程安全性？ 2. Java中常用的实现线程安全的方式有哪些？ 3. 什么是锁？Java中有哪些类型的锁？ 4. 什么是死锁？如何避免死锁？ 5. Java中的并发容器有哪些？它们的特点和使用场景分别是什么？ 6. 什么是线程池？Java中如何使用线程池来管理线程？有哪些常用的线程池实现类？ 7. Java中的原子类是什么？它们如何保证原子性操作？ 8. 什么是可见性问题？Java中如何解决可见性问题？ 9. 什么是乐观锁和悲观锁？分别举例说明。 10. Java中的并发工具类有哪些？举例说明它们的使用场景。 11. 什么是CAS（Compare and Swap）操作？它在Java中的应用有哪些？ 12. Java中的volatile关键字有什么作用？它如何保证可见性和禁止指令重排序？ 13. Java中的线程间通信有哪些方式？举例说明它们的使用场景。 14. 什么是ABA问题？如何解决ABA问题？ 15. Java中的锁优化技术有哪些？分别举例说明。 这些问题涵盖了Java高并发的基本概念、常用的线程安全技术、并发容器、线程池、原子类、可见性问题、锁优化等内容，希望对你有帮助！如果有更多问题，请继续提问。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值