⑴ java 程序中怎麼保證多線程的運行安全
2.1.讀一致性
Java 中針對上述「讀不安全」的問題提供了關鍵字 volatile 來解決問題，被 volatile 修飾的成員變數，在內容發生更改的時候，會通知所有線程去主內存更新最新的值，這樣就解決了讀不安全的問題，實現了讀一致性。
但是，讀一致性是無法解決寫一致性的，雖然能夠使得每個線程都能及時獲取到最新的值，但是1.1中的寫一致性問題還是會存在。
既然如此，Java 為啥還要提供 volatile 關鍵字呢？這並非多餘的存在，在某些場景下只需要讀一致性的話，這個關鍵字就能夠滿足需求而且性能相對還不錯，因為其他的能夠保證「讀寫」都一直的辦法，多多少少存在一些犧牲。
2.2.寫一致性
Java 提供了三種方式來保證讀寫一致性，分別是互斥鎖、自旋鎖、線程隔離。
2.2.1.互斥鎖
互斥鎖只是一個鎖概念，在其他場景也叫做獨占鎖、悲觀鎖等，其實就是一個意思。它是指線程之間是互斥的，某一個線程獲取了某個資源的鎖，那麼其他線程就只能睡眠等待。
在 Java 中互斥鎖的實現一般叫做同步線程鎖，關鍵字 synchronized，它鎖住的范圍是它修飾的作用域，鎖住的對象是：當前對象（對象鎖）或類的全部對象（類鎖）——鎖釋放前，其他線程必將阻塞，保證鎖住范圍內的操作是原子性的，而且讀取的數據不存在一致性問題。
對象鎖：當它修飾方法、代碼塊時，將會鎖住當前對象
類鎖：修飾類、靜態方法時，則是鎖住類的所有對象
注意：鎖住的永遠是對象，鎖住的范圍永遠是 synchronized 關鍵字後面的花括弧劃定的代碼域。
2.2.2.自旋鎖
自旋鎖也只是一個鎖概念，在其他場景也叫做樂觀鎖等。
自旋鎖本質上是不加鎖，而是通過對比舊數據來決定是否更新：
⑵ Java多線程: 如何阻塞和繼續線程運行 （轉）
樓主怕是理解上有些錯誤。並不是說主進程與子線程的表現形式。
main()是主進程，在一個進程中可以有多個線程。
正確的代碼這樣寫你可能就更容易理解了。
public
class
test
{
public
static
void
main(string[]
args)
{
for
(int
i
=
1;
i
<
10;
i++)
{
system.out.println("main函數正在運行");
new
testthread().start();
}
}
}
class
testthread
extends
thread
{
public
void
run()
{
while
(!interrupted())
for
(int
i
=
0;
i
<
10;
i++)
{
system.out.println("thread函數正在運行"+getid());
try
{
sleep(1000);
}
catch
(interruptedexception
e)
{
}
}
}
}
⑶ Java線程啥時候阻塞
Java線程阻塞
Thread.sleep(long millis)和Thread.sleep(long millis, int nanos)靜態方法強制當前正在執行的線程休眠（暫停執行），以「減慢線程」。
Thread.sleep(1000);//線程會阻塞1秒
IO流，在讀寫和寫入操作的時候，都是耗時的，也會導致線程阻塞
⑷ Java多線程之阻塞I/O如何中斷
阻塞的I/O線程在關閉線程時並不會被打斷，需要關閉資源才能打斷。
1.執行socketInput.close();阻塞可中斷。
2.執行System.in.close();阻塞沒有中斷。
復制代碼
package Thread.Interrupting;
import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
public class CloseResource {
public static void main(String[] args) throws Exception {
//堵塞的I/O線程不會被打斷，需要關閉資源才能打斷
ExecutorService exec = Executors.newCachedThreadPool();
ServerSocket server = new ServerSocket(8080);
InputStream socketInput = new Socket("localhost", 8080)
.getInputStream();
exec.execute(new IOBlocked(socketInput));
exec.execute(new IOBlocked(System.in));
TimeUnit.MILLISECONDS.sleep(100);
System.out.println("Shutting down all threads");
exec.shutdownNow();
TimeUnit.SECONDS.sleep(1);
System.out.println("Closing " + socketInput.getClass().getName());
socketInput.close();
TimeUnit.SECONDS.sleep(1);
System.out.println("Close " + System.in.getClass().getName());
System.in.close();
}
}
復制代碼
被阻塞的nio通道在關閉線程後會自動響應中斷阻塞，不需要關閉底層資源。
復制代碼
package Thread.Interrupting;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousCloseException;
import java.nio.channels.ClosedByInterruptException;
import java.nio.channels.SocketChannel;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
class NIOBlocked implements Runnable {
private final SocketChannel sc;
public NIOBlocked(SocketChannel sc) {
this.sc = sc;
}
@Override
public void run() {
try {
System.out.println("Waiting for read() in " + this);
sc.read(ByteBuffer.allocate(1));
} catch (ClosedByInterruptException e) {
System.out.println("ClosedByInterruptException");
} catch (AsynchronousCloseException e) {
System.out.println("AsynchronousCloseException");
} catch (IOException e) {
throw new RuntimeException(e);
}
System.out.println("Exiting NIOBlocked.run() " + this);
}
}
public class NIOInterruption {
public static void main(String[] args) throws Exception {
//被阻塞的nio通道會自動地響應中斷
ExecutorService exec = Executors.newCachedThreadPool();
ServerSocket server = new ServerSocket(8080);
InetSocketAddress isa = new InetSocketAddress("localhost", 8080);
SocketChannel sc1 = SocketChannel.open(isa);
SocketChannel sc2 = SocketChannel.open(isa);
Future<?> f = exec.submit(new NIOBlocked(sc1));
exec.execute(new NIOBlocked(sc2));
exec.shutdown();
TimeUnit.SECONDS.sleep(1);
f.cancel(true);
TimeUnit.SECONDS.sleep(1);
sc2.close();
}
}
⑸ Java多線程如何防止主線的阻塞
Java多線程在我們盡情的使用中存在著很多的問題，首先就是如何解決主線的阻塞問題。看完下面的代碼希望你對此有所啟發。在不斷的學習中才能有更好的技術突破。Java多線程防止主線阻塞代碼如下：if(e.getSource()==startItem) {//運行多線程爬蟲 stateLabel.setText("運行中...."); try { URL url_url=new URL(web_url); web_host=url_url.getHost(); } catch (MalformedURLException e2) { e2.printStackTrace(); } if(tpool==null) { // System.out.println("運行"); new Thread( new Runnable(){ public void run() { //要在另一個線程做得事情 // System.out.println("啦啦啦啦"); tpool=new ThreadPoolExecutor(minN,maxN,aliveT, TimeUnit.SECONDS, new LinkedBlockingQueue()/*, new ThreadPoolExecutor.CallerRunsPolicy()*/); //editor_pane.setText("創建線程池:"); String tempstr="" + "創建線程池:" + "設置最小線程數目："+minN+ "設置最大線程數目："+maxN+ "設置空閑線程存活時間(秒)："+aliveT+