JAVA编程，线程

直接调用线程的interrupt()方法，sleep(2000)休眠中的线程会抛出InterruptException异常，线程捕捉到该异常，如果没有后续 *** 作就什么也不做，线程自动结束。

flagstart=true;

while(flagstart)

{

///////

}

可以写在线程里面，这样才能响应你的点击 *** 作；

如果觉得写线程麻烦的话，可以考虑转换下思路，写在timer里面即可，timer事件是有间隔的，你点击的时候就可以响应了。

private bool flagstart; //定义为全局变量

private void timer1_Tick(object sender, EventArgs e)

{

if (flagstart) {//do something};

}

点击end的时候设置flagstart为false即可。

线程同步是多线程编程中重要的概念。它的基本意思就是同步各个线程对资源(比如全局变量、文件)的访问。如果不对资源访问进行线程同步，就会产生资源访问冲突的问题。比如，一个线程正在读取一个全局变量，而读取全局变量的这个语句在C++语言中只是一条语句，但在CPU指令处理这个过程的时候需要用多条指令来处理这个读取变量的过程。如果这一系列指令被另外一个线程打断了，也就是说CPU还没有执行完全部读取变量的所有指令就去执行另外一个线程了，而另外一个线程却要对这个全局变量进行修改，修改完后又返回原先的线程，继续执行读取变量的指令，此时变量的值已经改变了，这样第一个线程的执行结果就不是预料的结果了。线程同步是多线程编程中重要的概念。它的基本意思就是同步各个线程对资源(比如全局变量、文件)的访问。如果不对资源访问进行线程同步，就会产生资源访问冲突的问题。比如，一个线程正在读取一个全局变量，而读取全局变量的这个语句在C++语言中只是一条语句，但在CPU指令处理这个过程的时候需要用多条指令来处理这个读取变量的过程。如果这一系列指令被另外一个线程打断了，也就是说CPU还没有执行完全部读取变量的所有指令就去执行另外一个线程了，而另外一个线程却要对这个全局变量进行修改，修改完后又返回原先的线程，继续执行读取变量的指令，此时变量的值已经改变了，这样第一个线程的执行结果就不是预料的结果了。

首先，一般配置的linux，如果进程正在进行系统调用，那么此时进程就是正运行在内核态，而内核态的进程是不可被抢占的。

你说的这种情况，属于编译内核的时候开启了“内核可抢占”这个特性，这种情况下，即使进程正在内核态执行系统调用，也可以被其他进程抢占，这时，首先系统会在进程结构体中记录下这个进程当前是在内核态运行，然后，每个进程都有专属于自己的内核栈，系统会把当前的执行上下文信息都记录到这个进程的内核堆栈上。

以后这个进程恢复运行的时候，内核会从它的结构体中读到被打断前它处于内核态，进而从它的内核栈中读取当时的上下文信息并进行恢复，这样，进程就得以重新运行了。

有问题请追问

阻塞的I/O线程在关闭线程时并不会被打断，需要关闭资源才能打断。

1执行socketInputclose();阻塞可中断。

2执行Systeminclose();阻塞没有中断。

复制代码

package ThreadInterrupting;

import javaioIOException;

import javaioInputStream;

import javanetServerSocket;

import javanetSocket;

import javautilconcurrentExecutorService;

import javautilconcurrentExecutors;

import javautilconcurrentTimeUnit;

public class CloseResource {

public static void main(String[] args) throws Exception {

//堵塞的I/O线程不会被打断，需要关闭资源才能打断

ExecutorService exec = ExecutorsnewCachedThreadPool();

ServerSocket server = new ServerSocket(8080);

InputStream socketInput = new Socket("localhost", 8080)

getInputStream();

execexecute(new IOBlocked(socketInput));

execexecute(new IOBlocked(Systemin));

TimeUnitMILLISECONDSsleep(100);

Systemoutprintln("Shutting down all threads");

execshutdownNow();

TimeUnitSECONDSsleep(1);

Systemoutprintln("Closing " + socketInputgetClass()getName());

socketInputclose();

TimeUnitSECONDSsleep(1);

Systemoutprintln("Close " + SystemingetClass()getName());

Systeminclose();

}

}

复制代码

被阻塞的nio通道在关闭线程后会自动响应中断阻塞，不需要关闭底层资源。

复制代码

package ThreadInterrupting;

import javaioIOException;

import javanetInetSocketAddress;

import javanetServerSocket;

import javanioByteBuffer;

import javaniochannelsAsynchronousCloseException;

import javaniochannelsClosedByInterruptException;

import javaniochannelsSocketChannel;

import javautilconcurrentExecutorService;

import javautilconcurrentExecutors;

import javautilconcurrentFuture;

import javautilconcurrentTimeUnit;

class NIOBlocked implements Runnable {

private final SocketChannel sc;

public NIOBlocked(SocketChannel sc) {

thissc = sc;

}

@Override

public void run() {

try {

Systemoutprintln("Waiting for read() in " + this);

scread(ByteBufferallocate(1));

} catch (ClosedByInterruptException e) {

Systemoutprintln("ClosedByInterruptException");

} catch (AsynchronousCloseException e) {

Systemoutprintln("AsynchronousCloseException");

} catch (IOException e) {

throw new RuntimeException(e);

}

Systemoutprintln("Exiting NIOBlockedrun() " + this);

}

}

public class NIOInterruption {

public static void main(String[] args) throws Exception {

//被阻塞的nio通道会自动地响应中断

ExecutorService exec = ExecutorsnewCachedThreadPool();

ServerSocket server = new ServerSocket(8080);

InetSocketAddress isa = new InetSocketAddress("localhost", 8080);

SocketChannel sc1 = SocketChannelopen(isa);

SocketChannel sc2 = SocketChannelopen(isa);

Future<> f = execsubmit(new NIOBlocked(sc1));

execexecute(new NIOBlocked(sc2));

execshutdown();

TimeUnitSECONDSsleep(1);

fcancel(true);

TimeUnitSECONDSsleep(1);

sc2close();

}

}

以上就是关于JAVA编程，线程全部的内容，包括:JAVA编程，线程、C#中如何通过按钮打断循环、线程同步在多线程编程中有什么作用等相关内容解答，如果想了解更多相关内容，可以关注我们，你们的支持是我们更新的动力！