java并發(fā)問題概述
1什么是并發(fā)問題。
多個(gè)進(jìn)程或線程同時(shí)(或著說在同一段時(shí)間內(nèi))訪問同一資源會(huì)產(chǎn)生并發(fā)問題。
銀行兩操作員同時(shí)操作同一賬戶就是典型的例子。比如A、B操作員同時(shí)讀取一余額為1000元的賬戶，A操作員為該賬戶增加100元，B操作員同時(shí)為該賬戶減去50元，A先提交，B后提交。最后實(shí)際賬戶余額為1000-50=950元，但本該為1000+100-50=1050。這就是典型的并發(fā)問題。如何解決？可以用鎖。
2java中synchronized的用法
用法1
public class Test{
public synchronized void print(){
….;
}
}
某線程執(zhí)行print()方法，則該對(duì)象將加鎖。其它線程將無法執(zhí)行該對(duì)象的所有synchronized塊。
用法2
public class Test{
public void print(){
synchronized(this){
//鎖住本對(duì)象
…;
}
}
}
同用法1, 但更能體現(xiàn)synchronized用法的本質(zhì)。
用法3
public class Test{
private String a = “test”;
public void print(){
synchronized(a){
//鎖住a對(duì)象
…;
}
}
public synchronized void t(){
…;
//這個(gè)同步代碼塊不會(huì)因?yàn)閜rint()而鎖定.
}
}
執(zhí)行print()，會(huì)給對(duì)象a加鎖，注意不是給Test的對(duì)象加鎖，也就是說Test對(duì)象的其它synchronized方法不會(huì)因?yàn)閜rint()而被鎖。同步代碼塊執(zhí)行完，則釋放對(duì)a的鎖。
為了鎖住一個(gè)對(duì)象的代碼塊而不影響該對(duì)象其它synchronized塊的高性能寫法：
public class Test{
private byte[] lock = new byte[0];
public void print(){
synchronized(lock){
…;
}
}
public synchronized void t(){
…;
}
}
靜態(tài)方法的鎖
public class Test{
public synchronized static void execute(){
…;
}
}
效果同
public class Test{
public static void execute(){
synchronized(TestThread.class){
…;
}
}
}
3 Java中的鎖與排隊(duì)上廁所。
鎖就是阻止其它進(jìn)程或線程進(jìn)行資源訪問的一種方式，即鎖住的資源不能被其它請(qǐng)求訪問。在JAVA中，sychronized關(guān)鍵字用來對(duì)一個(gè)對(duì)象加鎖。比如:
public class MyStack {
int idx = 0;
char [] data = new char[6];
public synchronized void push(char c) {
data[idx] = c;
idx++;
}
public synchronized char pop() {
idx--;
return data[idx];
}
public static void main(String args[]){
MyStack m = new MyStack();
/**
下面對(duì)象m被加鎖。嚴(yán)格的說是對(duì)象m的所有synchronized塊被加鎖。
如果存在另一個(gè)試圖訪問m的線程T，那么T無法執(zhí)行m對(duì)象的push和
pop方法。
*/
m.pop();
//對(duì)象m被加鎖。
}
}
Java的加鎖解鎖跟多個(gè)人排隊(duì)等一個(gè)公共廁位完全一樣。第一個(gè)人進(jìn)去后順手把門從里面鎖住，其它人只好排隊(duì)等。第一個(gè)人結(jié)束后出來時(shí)，門才會(huì)打開（解鎖）。輪到第二個(gè)人進(jìn)去，同樣他又會(huì)把門從里面鎖住，其它人繼續(xù)排隊(duì)等待。
用廁所理論可以很容易明白:一個(gè)人進(jìn)了一個(gè)廁位，這個(gè)廁位就會(huì)鎖住，但不會(huì)導(dǎo)致另一個(gè)廁位也被鎖住，因?yàn)橐粋€(gè)人不能同時(shí)蹲在兩個(gè)廁位里。對(duì)于Java就是說：Java中的鎖是針對(duì)同一個(gè)對(duì)象的，不是針對(duì)class的?？聪吕?/p>
MyStatckm1=newMyStack(); MyStatckm2=newMystatck(); m1.pop(); m2.pop();
m1對(duì)象的鎖是不會(huì)影響m2的鎖的，因?yàn)樗鼈儾皇峭粋€(gè)廁位。就是說，假設(shè)有3線程t1,t2,t3操作m1，那么這3個(gè)線程只可能在m1上排隊(duì)等，假設(shè)另2個(gè)線程t8,t9在操作m2，那么t8,t9只會(huì)在m2上等待。而t2和t8則沒有關(guān)系，即使m2上的鎖釋放了，t1,t2,t3可能仍要在m1上排隊(duì)。原因無它，不是同一個(gè)廁位耳。
Java不能同時(shí)對(duì)一個(gè)代碼塊加兩個(gè)鎖，這和數(shù)據(jù)庫鎖機(jī)制不同，數(shù)據(jù)庫可以對(duì)一條記錄同時(shí)加好幾種不同的鎖。
4何時(shí)釋放鎖？
一般是執(zhí)行完畢同步代碼塊（鎖住的代碼塊）后就釋放鎖，也可以用wait()方式半路上釋放鎖。wait()方式就好比蹲廁所到一半，突然發(fā)現(xiàn)下水道堵住了，不得已必須出來站在一邊，好讓修下水道師傅(準(zhǔn)備執(zhí)行notify的一個(gè)線程）進(jìn)去疏通馬桶，疏通完畢，師傅大喊一聲:“已經(jīng)修好了”(notify)，剛才出來的同志聽到后就重新排隊(duì)。注意啊，必須等師傅出來啊，師傅不出來，誰也進(jìn)不去。也就是說notify后，不是其它線程馬上可以進(jìn)入封鎖區(qū)域活動(dòng)了，而是必須還要等notify代碼所在的封鎖區(qū)域執(zhí)行完畢從而釋放鎖以后，其它線程才可進(jìn)入。
這里是wait與notify代碼示例：
public synchronized char pop() {
char c;
while (buffer.size() == 0) {
try {
this.wait();
//從廁位里出來
}
catch (InterruptedException e) {
// ignore it…
}
}
c = ((Character)buffer.remove(buffer.size()-1)).
charValue();
return c;
}
public synchronized void push(char c) {
this.notify();
//通知那些wait()的線程重新排隊(duì)。注意：僅僅是通知它們重新排隊(duì)。
Character charObj = new Character(c);
buffer.addElement(charObj);
}
//執(zhí)行完畢，釋放鎖。那些排隊(duì)的線程就可以進(jìn)來了。
再深入一些。
由于wait()操作而半路出來的同志沒收到notify信號(hào)前是不會(huì)再排隊(duì)的，他會(huì)在旁邊看著這些排隊(duì)的人(其中修水管師傅也在其中）。注意，修水管的師傅不能插隊(duì)，也得跟那些上廁所的人一樣排隊(duì)，不是說一個(gè)人蹲了一半出來后，修水管師傅就可以突然冒出來然后立刻進(jìn)去搶修了，他要和原來排隊(duì)的那幫人公平競(jìng)爭，因?yàn)樗彩莻€(gè)普通線程。如果修水管師傅排在后面，則前面的人進(jìn)去后，發(fā)現(xiàn)堵了，就wait，然后出來站到一邊，再進(jìn)去一個(gè)，再wait，出來，站到一邊，只到師傅進(jìn)去執(zhí)行notify.這樣，一會(huì)兒功夫，排隊(duì)的旁邊就站了一堆人，等著notify.
終于，師傅進(jìn)去，然后notify了，接下來呢？
1.有一個(gè)wait的人（線程）被通知到。
2.為什么被通知到的是他而不是另外一個(gè)wait的人？取決于JVM.我們無法預(yù)先
判斷出哪一個(gè)會(huì)被通知到。也就是說，優(yōu)先級(jí)高的不一定被優(yōu)先喚醒，等待
時(shí)間長的也不一定被優(yōu)先喚醒，一切不可預(yù)知！(當(dāng)然，如果你了解該JVM的
實(shí)現(xiàn)，則可以預(yù)知）。
3.他（被通知到的線程）要重新排隊(duì)。
4.他會(huì)排在隊(duì)伍的第一個(gè)位置嗎？回答是：不一定。他會(huì)排最后嗎？也不一定。
但如果該線程優(yōu)先級(jí)設(shè)的比較高，那么他排在前面的概率就比較大。
5.輪到他重新進(jìn)入廁位時(shí)，他會(huì)從上次wait()的地方接著執(zhí)行，不會(huì)重新執(zhí)行。
惡心點(diǎn)說就是，他會(huì)接著拉巴巴，不會(huì)重新拉。
6.如果師傅notifyAll().則那一堆半途而廢出來的人全部重新排隊(duì)。順序不可知。
JavaDOC上說，Theawakenedthreadswillnotbeabletoproceeduntilthecurrentthreadrelinquishesthelockonthisobject(當(dāng)前線程釋放鎖前，喚醒的線程不能去執(zhí)行）。
這用廁位理論解釋就是顯而易見的事。
5Lock的使用
用synchronized關(guān)鍵字可以對(duì)資源加鎖。用Lock關(guān)鍵字也可以。它是JDK1.5中新增內(nèi)容。用法如下：
class BoundedBuffer {
final Lock lock = new ReentrantLock();
final Condition notFull = lock.newCondition();
final Condition notEmpty = lock.newCondition();
final Object[] items = new Object[100];
int putptr, takeptr, count;
public void put(Object x) throws InterruptedException {
lock.lock();
try {
while (count == items.length)
notFull.await();
items[putptr] = x;
if (++putptr == items.length) putptr = 0;
++count;
notEmpty.signal();
}
finally {
lock.unlock();
}
}
public Object take() throws InterruptedException {
lock.lock();
try {
while (count == 0)
notEmpty.await();
Object x = items[takeptr];
if (++takeptr == items.length) takeptr = 0;
--count;
notFull.signal();
return x;
}
finally {
lock.unlock();
}
}
}
(注：這是JavaDoc里的例子，是一個(gè)阻塞隊(duì)列的實(shí)現(xiàn)例子。所謂阻塞隊(duì)列，就是一個(gè)隊(duì)列如果滿了或者空了，都會(huì)導(dǎo)致線程阻塞等待。Java里的ArrayBlockingQueue提供了現(xiàn)成的阻塞隊(duì)列，不需要自己專門再寫一個(gè)了。)
一個(gè)對(duì)象的lock.lock()和lock.unlock()之間的代碼將會(huì)被鎖住。這種方式比起synchronize好在什么地方？簡而言之，就是對(duì)wait的線程進(jìn)行了分類。用廁位理論來描述，則是那些蹲了一半而從廁位里出來等待的人原因可能不一樣，有的是因?yàn)轳R桶堵了，有的是因?yàn)轳R桶沒水了。通知(notify)的時(shí)候，就可以喊：因?yàn)轳R桶堵了而等待的過來重新排隊(duì)（比如馬桶堵塞問題被解決了），或者喊，因?yàn)轳R桶沒水而等待的過來重新排隊(duì)(比如馬桶沒水問題被解決了）。這樣可以控制得更精細(xì)一些。不像synchronize里的wait和notify，不管是馬桶堵塞還是馬桶沒水都只能喊：剛才等待的過來排隊(duì)！假如排隊(duì)的人進(jìn)來一看，發(fā)現(xiàn)原來只是馬桶堵塞問題解決了，而自己渴望解決的問題（馬桶沒水）還沒解決，只好再回去等待(wait)，白進(jìn)來轉(zhuǎn)一圈，浪費(fèi)時(shí)間與資源。
Lock方式與synchronized對(duì)應(yīng)關(guān)系：
LockawaitsignalsignalAll
synchronizedwaitnotifynotifyAll
注意：不要在Lock方式鎖住的塊里調(diào)用wait、notify、notifyAll
6利用管道進(jìn)行線程間通信
原理簡單。兩個(gè)線程，一個(gè)操作PipedInputStream,一個(gè)操作PipedOutputStream。PipedOutputStream寫入的數(shù)據(jù)先緩存在Buffer中,如果Buffer滿，此線程wait。PipedInputStream讀出Buffer中的數(shù)據(jù)，如果Buffer沒數(shù)據(jù)，此線程wait。
jdk1.5中的阻塞隊(duì)列可實(shí)現(xiàn)同樣功能。
package io;
import java.io.*;
public class PipedStreamTest {
public static void main(String[] args) {
PipedOutputStream ops=new PipedOutputStream();
PipedInputStream pis=new PipedInputStream();
try{
ops.connect(pis);
//實(shí)現(xiàn)管道連接
new Producer(ops).run();
new Consumer(pis).run();
}
catch(Exception e){
e.printStackTrace();
}
}
}
//生產(chǎn)者
class Producer implements Runnable{
private PipedOutputStream ops;
public Producer(PipedOutputStream ops)
{
this.ops=ops;
}
public void run()
{
try{
ops.write("hell,spell".getBytes());
ops.close();
}
catch(Exception e)
{
e.printStackTrace();
}
}
}
//消費(fèi)者
class Consumer implements Runnable{
private PipedInputStream pis;
public Consumer(PipedInputStream pis)
{
this.pis=pis;
}
public void run()
{
try{
byte[] bu=new byte[100];
int len=pis.read(bu);
System.out.println(new String(bu,0,len));
pis.close();
}
catch(Exception e)
{
e.printStackTrace();
}
}
}
例2 對(duì)上面的程序做少許改動(dòng)就成了兩個(gè)線程。
package io;
import java.io.*;
public class PipedStreamTest {
public static void main(String[] args) {
PipedOutputStream ops=new PipedOutputStream();
PipedInputStream pis=new PipedInputStream();
try{
ops.connect(pis);
//實(shí)現(xiàn)管道連接
Producer p = new Producer(ops);
new Thread(p).start();
Consumer c = new Consumer(pis);
new Thread(c).start();
}
catch(Exception e){
e.printStackTrace();
}
}
}
//生產(chǎn)者
class Producer implements Runnable{
private PipedOutputStream ops;
public Producer(PipedOutputStream ops)
{
this.ops=ops;
}
public void run()
{
try{
for (;;){
ops.write("hell,spell".getBytes());
ops.close();
}
}
catch(Exception e)
{
e.printStackTrace();
}
}
}
//消費(fèi)者
class Consumer implements Runnable{
private PipedInputStream pis;
public Consumer(PipedInputStream pis)
{
this.pis=pis;
}
public void run()
{
try{
for (;;){
byte[] bu=new byte[100];
int len=pis.read(bu);
System.out.println(new String(bu,0,len));
}
pis.close();
}
catch(Exception e)
{
e.printStackTrace();
}
}
}
例3. 這個(gè)例子更加貼進(jìn)應(yīng)用
import java.io.*;
public class PipedIO {
//程序運(yùn)行后將sendFile文件的內(nèi)容拷貝到receiverFile文件中
public static void main(String args[]){
try{
//構(gòu)造讀寫的管道流對(duì)象
PipedInputStream pis=new PipedInputStream();
PipedOutputStream pos=new PipedOutputStream();
//實(shí)現(xiàn)關(guān)聯(lián)
pos.connect(pis);
//構(gòu)造兩個(gè)線程，并且啟動(dòng)。
new Sender(pos,”c:\text2.txt”).start();
new Receiver(pis,”c:\text3.txt”).start();
}
catch(IOException e){
System.out.println(“Pipe Error”+ e);
}
}
}
//線程發(fā)送
class Sender extends Thread{
PipedOutputStream pos;
File file;
//構(gòu)造方法
Sender(PipedOutputStream pos, String fileName){
this.pos=pos;
file=new File(fileName);
}
//線程運(yùn)行方法
public void run(){
try{
//讀文件內(nèi)容
FileInputStream fs=new FileInputStream(file);
int data;
while((data=fs.read())!=-1){
//寫入管道始端
pos.write(data);
}
pos.close();
}
catch(IOException e) {
System.out.println(“Sender Error” +e);
}
}
}
//線程讀
class Receiver extends Thread{
PipedInputStream pis;
File file;
//構(gòu)造方法
Receiver(PipedInputStream pis, String fileName){
this.pis=pis;
file=new File(fileName);
}
//線程運(yùn)行
public void run(){
try {
//寫文件流對(duì)象
FileOutputStream fs=new FileOutputStream(file);
int data;
//從管道末端讀
while((data=pis.read())!=-1){
//寫入本地文件
fs.write(data);
}
pis.close();
}
catch(IOException e){
System.out.println("Receiver Error" +e);
}
}
}
7阻塞隊(duì)列
阻塞隊(duì)列可以代替管道流方式來實(shí)現(xiàn)進(jìn)水管/排水管模式（生產(chǎn)者/消費(fèi)者).JDK1.5提供了幾個(gè)現(xiàn)成的阻塞隊(duì)列.現(xiàn)在來看ArrayBlockingQueue的代碼如下：
這里是一個(gè)阻塞隊(duì)列
BlockingQueue blockingQ = new ArrayBlockingQueue 10;
一個(gè)線程從隊(duì)列里取
for(;;){
Object o = blockingQ.take();//隊(duì)列為空，則等待（阻塞）
}
另一個(gè)線程往隊(duì)列存
for(;;){
blockingQ.put(new Object());//隊(duì)列滿，則等待（阻塞）
}
可見，阻塞隊(duì)列使用起來比管道簡單。
8使用Executors、Executor、ExecutorService、ThreadPoolExecutor
可以使用線程管理任務(wù)。還可以使用jdk1.5提供的一組類來更方便的管理任務(wù)。從這些類里我們可以體會(huì)一種面向任務(wù)的思維方式。這些類是：
Executor接口。使用方法：
Executor executor = anExecutor;//生成一個(gè)Executor實(shí)例。 executor.execute(new RunnableTask1());
用意：使用者只關(guān)注任務(wù)執(zhí)行，不用操心去關(guān)注任務(wù)的創(chuàng)建、以及執(zhí)行細(xì)節(jié)等這些第三方實(shí)現(xiàn)者關(guān)心的問題。也就是說，把任務(wù)的調(diào)用執(zhí)行和任務(wù)的實(shí)現(xiàn)解耦。
實(shí)際上，JDK1.5中已經(jīng)有該接口出色的實(shí)現(xiàn)。夠用了。
Executors是一個(gè)如同Collections一樣的工廠類或工具類，用來產(chǎn)生各種不同接口的實(shí)例。
ExecutorService接口它繼承自Executor.Executor只管把任務(wù)扔進(jìn)executor()里去執(zhí)行，剩余的事就不管了。而ExecutorService則不同，它會(huì)多做點(diǎn)控制工作。比如：
class NetworkService {
private final ServerSocket serverSocket;
private final ExecutorService pool;
public NetworkService(int port, int poolSize) throws IOException {
serverSocket = new ServerSocket(port);
pool = Executors.newFixedThreadPool(poolSize);
}
public void serve() {
try {
for (;;) {
pool.execute(new Handler(serverSocket.accept()));
}
}
catch (IOException ex) {
pool.shutdown();
//不再執(zhí)行新任務(wù)
}
}
}
class Handler implements Runnable {
private final Socket socket;
Handler(Socket socket) {
this.socket = socket;
}
public void run() {
// read and service request
}
}
ExecutorService(也就是代碼里的pool對(duì)象）執(zhí)行shutdown后，它就不能再執(zhí)行新任務(wù)了，但老任務(wù)會(huì)繼續(xù)執(zhí)行完畢，那些等待執(zhí)行的任務(wù)也不再等待了。
任務(wù)提交者與執(zhí)行者通訊
public static void main(String args[])throws Exception {
ExecutorService executor = Executors.newSingleThreadExecutor();
Callable task = new Callable(){
public String call()throws Exception{
return “test”;
}
}
;
Future f = executor.submit(task);
String result = f.get();
//等待（阻塞）返回結(jié)果
System.out.println(result);
executor.shutdown();
}
Executors.newSingleThreadExecutor()取得的Executor實(shí)例有以下特性:
任務(wù)順序執(zhí)行.比如：
executor.submit(task1); executor.submit(task2);
必須等task1執(zhí)行完，task2才能執(zhí)行。
task1和task2會(huì)被放入一個(gè)隊(duì)列里，由一個(gè)工作線程來處理。即：一共有2個(gè)線程(主線程、處理任務(wù)的工作線程）。
其它的類請(qǐng)參考JavaDoc
9并發(fā)流程控制
本節(jié)例子來自溫少的Java并發(fā)教程，可能會(huì)有改動(dòng)。向溫少致敬。
CountDownLatch門插銷計(jì)數(shù)器
啟動(dòng)線程，然后等待線程結(jié)束。即常用的主線程等所有子線程結(jié)束后再執(zhí)行的問題。
public static void main(String[] args)throws Exception {
// TODO Auto-generated method stub
final int count=10;
final CountDownLatch completeLatch = new CountDownLatch(count);
//定義了門插銷的數(shù)目是10
for (int i=0;i<count;i++){
Thread thread = new Thread("worker thread"+i){
public void run(){
//do xxxx
completeLatch.countDown();
//減少一根門插銷
}
}
;
thread.start();
}
completeLatch.await();
//如果門插銷還沒減完則等待。
}
JDK1.4時(shí)，常用辦法是給子線程設(shè)置狀態(tài)，主線程循環(huán)檢測(cè)。易用性和效率都不好。
啟動(dòng)很多線程，等待通知才能開始
public static void main(String[] args) throws Exception {
// TODO Auto-generated method stub
final CountDownLatch startLatch = new CountDownLatch(1);
//定義了一根門插銷
for (int i = 0; i < 10; i++) {
Thread thread = new Thread("worker thread" + i) {
public void run() {
try {
startLatch.await();
//如果門插銷還沒減完則等待
}
catch (InterruptedException e) {
}
// do xxxx
}
}
;
thread.start();
}
startLatch.countDown();
//減少一根門插銷
}
CycliBarrier. 等所有線程都達(dá)到一個(gè)起跑線后才能開始繼續(xù)運(yùn)行。
public class CycliBarrierTest implements Runnable {
private CyclicBarrier barrier;
public CycliBarrierTest(CyclicBarrier barrier) {
this.barrier = barrier;
}
public void run() {
//do xxxx;
try {
this.barrier.await();
//線程運(yùn)行至此會(huì)檢查是否其它線程都到齊了，沒到齊就繼續(xù)等待。到齊了就執(zhí)行barrier的run函數(shù)體里的內(nèi)容
}
catch (Exception e) {
}
}
/**
* @param args
*/
public static void main(String[] args) {
//參數(shù)2代表兩個(gè)線程都達(dá)到起跑線才開始一起繼續(xù)往下執(zhí)行
CyclicBarrier barrier = new CyclicBarrier(2, new Runnable() {
public void run() {
//do xxxx;
}
}
);
Thread t1 = new Thread(new CycliBarrierTest(barrier));
Thread t2 = new Thread(new CycliBarrierTest(barrier));
t1.start();
t2.start();
}
}
這簡化了傳統(tǒng)的用計(jì)數(shù)器+wait/notifyAll來實(shí)現(xiàn)該功能的方式。
10并發(fā)3定律
Amdahl定律.給定問題規(guī)模，可并行化部分占12%，那么即使把并行運(yùn)用到極致，系統(tǒng)的性能最多也只能提高1/(1-0.12)=1.136倍。即：并行對(duì)提高系統(tǒng)性能有上限。
Gustafson定律.Gustafson定律說Amdahl定律沒有考慮隨著cpu的增多而有更多的計(jì)算能力可被使用。其本質(zhì)在于更改問題規(guī)模從而可以把Amdahl定律中那剩下的88%的串行處理并行化，從而可以突破性能門檻。本質(zhì)上是一種空間換時(shí)間。
Sun-Ni定律.是前兩個(gè)定律的進(jìn)一步推廣。其主要思想是計(jì)算的速度受限于存儲(chǔ)而不是CPU的速度.所以要充分利用存儲(chǔ)空間等計(jì)算資源，盡量增大問題規(guī)模以產(chǎn)生更好/更精確的解.
11由并發(fā)到并行
計(jì)算機(jī)識(shí)別物體需要飛速的計(jì)算，以至于芯片發(fā)熱發(fā)燙，而人在識(shí)別物體時(shí)卻一目了然，卻并不會(huì)導(dǎo)致某個(gè)腦細(xì)胞被燒熱燒焦（夸張）而感到不適，是由于大腦是一個(gè)分布式并行運(yùn)行系統(tǒng)，就像google用一些廉價(jià)的linux服務(wù)器可以進(jìn)行龐大復(fù)雜的計(jì)算一樣，大腦內(nèi)部無數(shù)的神經(jīng)元的獨(dú)自計(jì)算，互相分享成果，從而瞬間完成需要單個(gè)cpu萬億次運(yùn)算才能有的效果。試想，如果在并行處理領(lǐng)域有所創(chuàng)建，將對(duì)計(jì)算機(jī)的發(fā)展和未來產(chǎn)生不可估量的影響。當(dāng)然，其中的挑戰(zhàn)也可想而知：許多的問題是并不容易輕易就“分割”的了的。
總結(jié)
以上就是本文關(guān)于java并發(fā)問題概述的全部內(nèi)容，希望對(duì)大家有所幫助。感興趣的朋友可以繼續(xù)參閱本站其他相關(guān)專題，如有不足之處，歡迎留言指出。感謝朋友們對(duì)本站的支持！
相關(guān)文章
這篇文章主要給大家介紹了關(guān)于在IDEA中配置Maven鏡像的最新方法,Maven是一個(gè)流行的Java項(xiàng)目構(gòu)建工具,它依賴于互聯(lián)網(wǎng)上的Mave中央倉庫來下載和管理項(xiàng)目依賴庫,文中通過圖文介紹的非常詳細(xì),需要的朋友可以參考下2023-11-11
這篇文章主要介紹了IDEA設(shè)置Tab選項(xiàng)卡快速的操作，具有很好的參考價(jià)值，希望對(duì)大家有所幫助。一起跟隨小編過來看看吧2021-02-02
這篇文章主要介紹了Spring Bean的生命周期的相關(guān)資料,需要的朋友可以參考下2016-09-09
java根據(jù)方法名稱取得反射方法的參數(shù)類型示例
利用java反射原理調(diào)用方法時(shí)，常先需要傳入方法參數(shù)數(shù)組才能取得方法。該方法參數(shù)數(shù)組采用動(dòng)態(tài)取得的方式比較合適2014-02-02
Java線程中synchronized和volatile關(guān)鍵字的區(qū)別詳解
這篇文章主要介紹了Java線程中synchronized和volatile關(guān)鍵字的區(qū)別詳解,synchronzied既能夠保障可見性,又能保證原子性,而volatile只能保證可見性,無法保證原子性,volatile不需要加鎖,比synchronized更輕量級(jí),不會(huì)阻塞線程,需要的朋友可以參考下2024-01-01
bus稱之為springcloud中消息總線,主要用來在微服務(wù)系統(tǒng)中實(shí)現(xiàn)遠(yuǎn)端配置更新時(shí)通過廣播形式通知所有客戶端刷新配置信息,避免手動(dòng)重啟服務(wù)的工作，這篇文章主要介紹了SpringCloud?Bus組件的使用,需要的朋友可以參考下2022-03-03
Java面試之動(dòng)態(tài)規(guī)劃與組合數(shù)
這篇文章主要介紹了Java面試之動(dòng)態(tài)規(guī)劃與組合數(shù)的相關(guān)知識(shí)，非常不錯(cuò)，具有一定的參考借鑒價(jià)值,需要的朋友可以參考下2019-09-09
Feign使用@PathVariable注解在URL中插入變量,類似于SpringMVC的用法,通過示例展示了如何使用該注解,并在實(shí)際調(diào)用中替換占位符2024-11-11
這篇文章主要介紹了Java中的Spring Security配置過濾器，文章通過圍繞文章主題的相關(guān)資料展開詳細(xì)內(nèi)容介紹，具有一定的參考價(jià)值，需要的小伙伴可以參考一下2022-05-05
解讀String字符串導(dǎo)致的JVM內(nèi)存泄漏問題
這篇文章主要介紹了解讀String字符串導(dǎo)致的JVM內(nèi)存泄漏問題,具有很好的參考價(jià)值,希望對(duì)大家有所幫助,如有錯(cuò)誤或未考慮完全的地方,望不吝賜教2023-07-07