并发基础初步认识

public class MyThread extends Thread {
public void run() {
System.out.println("MyThread.run()");
}
}
MyThread myThread1 = new MyThread();
MyThread myThread2 = new MyThread();
myThread1.start(); myThread2.start();

public class CallableDemo implements Callable {
public static void main(String[] args) throws ExecutionException, InterruptedException {
ExecutorService executorService=Executors.newFixedThreadPool(1);
CallableDemo callableDemo=new CallableDemo();
Future future=executorService.submit(callableDemo);
System.out.println(future.get());
executorService.shutdown();
}
@Override
public String call() throws Exception {
　　int a=1;
　　 int b=2;
　　System.out.println(a+b);
　　return "执行结果:"+(a+b);
}
}

static JNINativeMethod methods[] = {
{"start0", "()V", (void *)&JVM_StartThread},
{"stop0", "(" OBJ ")V", (void *)&JVM_StopThread},
{"isAlive", "()Z", (void *)&JVM_IsThreadAlive},
{"suspend0", "()V", (void *)&JVM_SuspendThread},
{"resume0", "()V", (void *)&JVM_ResumeThread},
{"setPriority0", "(I)V", (void *)&JVM_SetThreadPriority},
{"yield", "()V", (void *)&JVM_Yield},
{"sleep", "(J)V", (void *)&JVM_Sleep},
{"currentThread", "()" THD, (void *)&JVM_CurrentThread},
{"countStackFrames", "()I", (void *)&JVM_CountStackFrames},
{"interrupt0", "()V", (void *)&JVM_Interrupt},
{"isInterrupted", "(Z)Z", (void *)&JVM_IsInterrupted},
{"holdsLock", "(" OBJ ")Z", (void *)&JVM_HoldsLock},
{"getThreads", "()[" THD, (void *)&JVM_GetAllThreads},
{"dumpThreads", "([" THD ")[[" STE, (void *)&JVM_DumpThreads},
};
#undef THD
#undef OBJ
#undef STE
JNIEXPORT void JNICALL
Java_java_lang_Thread_registerNatives(JNIEnv *env, jclass cls)
{
(*env)->RegisterNatives(env, cls, methods, ARRAY_LENGTH(methods));
}

JVM_ENTRY(void,JVM_StartThread(JNIEnv*env,jobject jthread))
JVMWrapper("JVM_StartThread");
........
native_thread = new JavaThread(&thread_entry,sz);
......

JavaThread::JavaThread(ThreadFunction entry_point, size_t stack_sz) :
Thread()
#if INCLUDE_ALL_GCS
, _satb_mark_queue(&_satb_mark_queue_set),
_dirty_card_queue(&_dirty_card_queue_set)
#endif // INCLUDE_ALL_GCS
{
if (TraceThreadEvents) {
tty->print_cr("creating thread %p", this);
}
initialize();
_jni_attach_state = _not_attaching_via_jni;
set_entry_point(entry_point);
// Create the native thread itself.
// %note runtime_23
os::ThreadType thr_type = os::java_thread;
thr_type = entry_point == &compiler_thread_entry ? os::compiler_thread :
os::java_thread;
os::create_thread(this, thr_type, stack_sz);
_safepoint_visible = false;
// The _osthread may be NULL here because we ran out of memory (too many threads active).
// We need to throw and OutOfMemoryError - however we cannot do this here because the caller
// may hold a lock and all locks must be unlocked before throwing the exception (throwing
// the exception consists of creating the exception object & initializing it, initialization
// will leave the VM via a JavaCall and then all locks must be unlocked).
//
// The thread is still suspended when we reach here. Thread must be explicit started
// by creator! Furthermore, the thread must also explicitly be added to the Threads list
// by calling Threads:add. The reason why this is not done here, is because the thread
// object must be fully initialized (take a look at JVM_Start)
}

void Thread::start(Thread* thread) {
trace("start", thread);
// Start is different from resume in that its safety is guaranteed by context or
// being called from a Java method synchronized on the Thread object.
if (!DisableStartThread) {
if (thread->is_Java_thread()) {
// Initialize the thread state to RUNNABLE before starting this thread.
// Can not set it after the thread started because we do not know the
// exact thread state at that time. It could be in MONITOR_WAIT or
// in SLEEPING or some other state.
java_lang_Thread::set_thread_status(((JavaThread*)thread)->threadObj(),
java_lang_Thread::RUNNABLE);
}
os::start_thread(thread);
}
}

public class InterruptDemo {
　　private static int i;
　　public static void main(String[] args) throws InterruptedException {
　　　　Thread thread=new Thread(()->{
　　　　　　while(!Thread.currentThread().isInterrupted()){ //默认情况下isInterrupted 返回 false、通过 thread.interrupt 变成了 true
　　　　　　　　i++;
　　　　　　}
　　　　　　System.out.println("Num:"+i);
　　　　},"interruptDemo");
　　　　thread.start();
　　　　TimeUnit.SECONDS.sleep(1);
　　　　thread.interrupt(); //加和不加的效果
　　}
}

public class InterruptDemo {
　　private static int i;
　　public static void main(String[] args) throws InterruptedException {
　　　　Thread thread=new Thread(()->{
　　　　　　while(true){
　　　　　　　　if(Thread.currentThread().isInterrupted()){
　　　　　　　　　　System.out.println("before:"+Thread.currentThread().isInterrupted());
　　　　　　　　　　Thread.interrupted(); //对线程进行复位，由 true 变成 false
　　　　　　　　　　System.out.println("after:"+Thread.currentThread().isInterrupted());
　　　　　　　　}
　　　　　　}
　　　　},"interruptDemo");
　　　　thread.start();
　　　　TimeUnit.SECONDS.sleep(1);
　　　　thread.interrupt();
　　}
}

public class InterruptDemo {
　　private static int i;
　　public static void main(String[] args) throws InterruptedException{
　　　　Thread thread=new Thread(()->{
　　　　　　while(!Thread.currentThread().isInterrupted()){
　　　　　　　　i++;
　　　　　　}
　　　　　　System.out.println("Num:"+i);
　　　　},"interruptDemo");
　　　　thread.start();
　　　　TimeUnit.SECONDS.sleep(1);
　　　　thread.interrupt();
　　　　System.out.println(th
　　　　read.isInterrupted());
　　}　　
}

public class InterruptDemo {
　　private static int i;
　　public static void main(String[] args) throws InterruptedException {
　　　　Thread thread=new Thread(()->{
　　　　　　while(!Thread.currentThread().isInterrupted()){
　　　　　　　　try {
　　　　　　　　　　TimeUnit.SECONDS.sleep(1);
　　　　　　　　} catch (InterruptedException e) {
　　　　　　　　　　e.printStackTrace();
　　　　　　　　}
　　　　　　}
　　　　　　System.out.println("Num:"+i);
　　　　},"interruptDemo");
　　　　thread.start();
　　　　TimeUnit.SECONDS.sleep(1);
　　　　thread.interrupt();
　　　　System.out.println(th
　　　　read.isInterrupted());
　　}
}

public void interrupt() {
if (this != Thread.currentThread())
checkAccess();
synchronized (blockerLock) {
Interruptible b = blocker;
if (b != null) {
interrupt0(); // Just to set the interrupt flag
b.interrupt(this);
return;
}
}
interrupt0();
}

JVM_ENTRY(void, JVM_Interrupt(JNIEnv* env, jobject jthread))
JVMWrapper("JVM_Interrupt");
// Ensure that the C++ Thread and OSThread structures aren‘t freed before we operate
oop java_thread = JNIHandles::resolve_non_null(jthread);
MutexLockerEx ml(thread->threadObj() == java_thread ? NULL : Threads_lock);
// We need to re-resolve the java_thread, since a GC might have happened during the
// acquire of the lock
JavaThread* thr = java_lang_Thread::thread(JNIHandles::resolve_non_null(jthread));
if (thr != NULL) {
Thread::interrupt(thr);
}
JVM_END

void Thread::interrupt(Thread* thread) {
trace("interrupt", thread);
debug_only(check_for_dangling_thread_pointer(thread);)
os::interrupt(thread);
}

JVM_ENTRY(void, JVM_Sleep(JNIEnv* env, jclass threadClass, jlong millis))
JVMWrapper("JVM_Sleep");
if (millis <0) {
THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), "timeout value is negative");
}
　　//　　判断并清除线程中断状态，如果中断状态为true,则抛出异常
if (Thread::is_interrupted (THREAD, true) && !HAS_PENDING_EXCEPTION) {
THROW_MSG(vmSymbols::java_lang_InterruptedException(), "sleep interrupted");
}
// Save current thread state and restore it at the end of this block.
// And set new thread state to SLEEPING.
JavaThreadSleepState jtss(thread);
　　....

JVM_END