概述
- Java线程映射到OS的线程
- 代码版本:oracle jdk 1.8
- java.lang.Thread implements Runnable
/* Make sure registerNatives is the first thing <clinit> does. */ private static native void registerNatives(); static { registerNatives(); }
说明:确保在创建线程对象执行<clinit>方法时,注册私有方法,关于此jni方法,暂时不知道,todo
属性字段
常用属性
private volatile String name;
private int priority;
private boolean daemon = false;
private Runnable target;
private ThreadGroup group;
ThreadLocal.ThreadLocalMap threadLocals = null;
ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;
其他属性
private Thread threadQ;
private long eetop;
/* Whether or not to single_step this thread. */
private boolean single_step;
/* JVM state */
private boolean stillborn = false;
/* What will be run. */
private Runnable target;
/* The context ClassLoader for this thread */
private ClassLoader contextClassLoader;
/* The inherited AccessControlContext of this thread */
private AccessControlContext inheritedAccessControlContext;
/* For autonumbering anonymous threads. */
private static int threadInitNumber;
private static synchronized int nextThreadNum() {
return threadInitNumber++;
}
/*
* The requested stack size for this thread, or 0 if the creator did
* not specify a stack size. It is up to the VM to do whatever it
* likes with this number; some VMs will ignore it.
*/
private long stackSize;
/*
* JVM-private state that persists after native thread termination.
*/
private long nativeParkEventPointer;
/*
* Thread ID
*/
private long tid;
/* For generating thread ID */
private static long threadSeqNumber;
private static synchronized long nextThreadID() {
return ++threadSeqNumber;
}
/* Java thread status for tools,
* initialized to indicate thread 'not yet started'
*/
private volatile int threadStatus = 0;
关于中断的属性
/**
* The argument supplied to the current call to
* java.util.concurrent.locks.LockSupport.park.
* Set by (private) java.util.concurrent.locks.LockSupport.setBlocker
* Accessed using java.util.concurrent.locks.LockSupport.getBlocker
*/
volatile Object parkBlocker;
/* The object in which this thread is blocked in an interruptible I/O
* operation, if any. The blocker's interrupt method should be invoked
* after setting this thread's interrupt status.
*/
private volatile Interruptible blocker;
private final Object blockerLock = new Object();
/* Set the blocker field; invoked via sun.misc.SharedSecrets from java.nio code
*/
void blockedOn(Interruptible b) {
synchronized (blockerLock) {
blocker = b;
}
}
说明:
- parkBlocker属性提供给LockSupport使用,提供现场信息
- blocker属性提供给可中断IO使用,java.nio使用
线程状态
线程状态,Thread内部枚举
public enum State {
/**
* Thread state for a thread which has not yet started.
*/
NEW,
/**
* Thread state for a runnable thread. A thread in the runnable
* state is executing in the Java virtual machine but it may
* be waiting for other resources from the operating system
* such as processor.
*/
RUNNABLE,
/**
* Thread state for a thread blocked waiting for a monitor lock.
* A thread in the blocked state is waiting for a monitor lock
* to enter a synchronized block/method or
* reenter a synchronized block/method after calling
* {@link Object#wait() Object.wait}.
*/
BLOCKED,
/**
* Thread state for a waiting thread.
* A thread is in the waiting state due to calling one of the
* following methods:
* <ul>
* <li>{@link Object#wait() Object.wait} with no timeout</li>
* <li>{@link #join() Thread.join} with no timeout</li>
* <li>{@link LockSupport#park() LockSupport.park}</li>
* </ul>
*
* <p>A thread in the waiting state is waiting for another thread to
* perform a particular action.
*
* For example, a thread that has called <tt>Object.wait()</tt>
* on an object is waiting for another thread to call
* <tt>Object.notify()</tt> or <tt>Object.notifyAll()</tt> on
* that object. A thread that has called <tt>Thread.join()</tt>
* is waiting for a specified thread to terminate.
*/
WAITING,
/**
* Thread state for a waiting thread with a specified waiting time.
* A thread is in the timed waiting state due to calling one of
* the following methods with a specified positive waiting time:
* <ul>
* <li>{@link #sleep Thread.sleep}</li>
* <li>{@link Object#wait(long) Object.wait} with timeout</li>
* <li>{@link #join(long) Thread.join} with timeout</li>
* <li>{@link LockSupport#parkNanos LockSupport.parkNanos}</li>
* <li>{@link LockSupport#parkUntil LockSupport.parkUntil}</li>
* </ul>
*/
TIMED_WAITING,
/**
* Thread state for a terminated thread.
* The thread has completed execution.
*/
TERMINATED;
}
线程的状态转换如下图
线程生命周期.png
构造器
各种构造器, 会调用init()方法
方法
常用方法
- 当前线程
public static native Thread currentThread();
会调用jvm/os,todo - 线程启动
public synchronized void start();
调用jni start0()方法,jvm/os,todo - 线程运行
@Override public void run() { if (target != null) { target.run(); } }
- Thread
- yield():通知os的scheduler,当前线程放弃时间片
- join()
join(...)- 底层使用Object类 wait()/notify()/notifyAll()
- 若中断,清除中断状态,抛出异常
- sleep(...)
若中断,清除中断状态,抛出异常
- Object
- wait()
wait(...)
若中断,清除中断状态,抛出异常 - notify()
notifyAll()
- wait()
- LockSupport
- park()
park(...)
parkNanos(...)
parkUntil(...)
若中断,直接返回,不清除中断状态,不抛异常 - unpark()
- park()
弃用方法
关于停止线程,在线程中断中说明,todo
- stop():不安全
- suspend():容易死锁
- resume():容易死锁
关于中断
- interrupt():调用jni interrupt0(),调用jvm/os,todo
- wait(...)/join(...)/sleep(...),清除中断状态,抛出异常
- InterruptibleChannel阻塞,channel关闭,设置中断状态
- Selector阻塞,select()方法返回,设置中断状态
- isIntettupted()
- interrupted()
返回中断状态,若中断,清除中断状态
网友评论