⑴ 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+