jdk研究

volatile 是什么意思？

如何看jdk源码？ 如何调试源码！---------仔细解读关键类，关键代码，常用的api的解释！ 自己有疑问的不懂地方
-------- 不懂的太多怎么办。。。。

求分享求带
求讲解原理啊！ 有老师还是比没有好得多！

关键代码、难懂代码是哪些啊！

承上启下

结构图？流水图？

哪些又是胶水代码呢、辅助代码

PACKAGE java.lang

Object

System

大量出现类似：
SecurityManager sm = getSecurityManager();---------- 涉及到java的安全机制
if (sm != null) {
sm.checkPermission(new RuntimePermission("getenv."+name));
}

System的gc调用的是 Runtime的gc：

public static void gc() {
Runtime.getRuntime().gc();
}

public static void runFinalization() {
Runtime.getRuntime().runFinalization();
}

public static void load(String filename) {
Runtime.getRuntime().load0(getCallerClass(), filename);
}

Thread implements Runnable

关键：当然就是它的 start方法-------- synchronized
public synchronized void start() {
if (threadStatus != 0)
throw new IllegalThreadStateException();
group.add(this);
start0();
if (stopBeforeStart) {
stop0(throwableFromStop);
}
}

private native void start0();

run方法：
private Runnable target;
public void run() {
if (target != null) {
target.run();
}
}

所以，真正运行的代码体在于实现类的run方法----- 实现自定义线程的两种方法：继承Thread和实现Runnable本质上是一样的，都是调用实现、继承类的 ，由Thread来启动，运行run方法

而，调用start方法，只是表明让这个Thread开始运行，去执行run里面内容

还有类似很多的native方法

线程的状态：

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;
}

public State getState() {---------------------- 在这个方法用得少。。。。
// get current thread state
return sun.misc.VM.toThreadState(threadStatus);
}

从这里可以看得出线程的状态： NEW RUNNABLE BLOCKED WAITING TIMED_WAITING TERMINATED

ThreadLocal<T>
主要就是访问 绑定在Thread上的集合类型变量：threadLocals

常用的api： get、set。。。

public T get() {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null) {
ThreadLocalMap.Entry e = map.getEntry(this);
if (e != null)
return (T)e.value;
}
return setInitialValue();
}

public void set(T value) {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);
else
createMap(t, value);
}

ThreadLocalMap getMap(Thread t) {
return t.threadLocals;
}

ThreadLocal.ThreadLocalMap threadLocals = null;

Throwable

关键:
printStackTrace:
getMessage()
getCause()

其实是调用另外的native方法实现的
private native int getStackTraceDepth();
private native StackTraceElement getStackTraceElement(int index);

String
属性
count 私有，但是调试的时候常见
offset
private int hash; // Default to 0
char value[]

format(String, Object...)
public static String format(String format, Object ... args) {
return new Formatter().format(format, args).toString();
}
valueOf 全返回string，方法名的意思应该是 string value of an char/int/.. variable
valueOf(char)
char data[] = {c};
return new String(0, 1, data);

valueOf(char[])
valueOf(char[], int, int)
valueOf(double)
valueOf(float)
valueOf(int) ----- 分别调用了相应的tostring方法
return Integer.toString(i, 10);
valueOf(long)
return Long.toString(l, 10);
valueOf(Object)

public static String valueOf(Object obj) {
return (obj == null) ? "null" : obj.toString();
}

一堆的构造方法：

String()
String(byte[])
String(byte[], Charset)
String(byte[], int)
String(byte[], int, int)
String(byte[], int, int, Charset)
String(byte[], int, int, int)
String(byte[], int, int, String)
String(byte[], String)
String(char[])
String(char[], int, int)
String(int, int, char[])
String(int[], int, int)
String(String)
String(StringBuffer)
String(StringBuilder)

常用的 equals 方法
public boolean equals(Object anObject) {
if (this == anObject) {
return true;
}
if (anObject instanceof String) {
String anotherString = (String)anObject;
int n = count;
if (n == anotherString.count) {
char v1[] = value;
char v2[] = anotherString.value;
int i = offset;
int j = anotherString.offset;
while (n-- != 0) {
if (v1[i++] != v2[j++])
return false;
}
return true;
}
}
return false;
}

public int compareTo(String anotherString) {
int len1 = count;
int len2 = anotherString.count;
int n = Math.min(len1, len2);
char v1[] = value;
char v2[] = anotherString.value;
int i = offset;
int j = anotherString.offset;

if (i == j) {
int k = i;
int lim = n + i;
while (k < lim) {
char c1 = v1[k];
char c2 = v2[k];
if (c1 != c2) {
return c1 - c2;
}
k++;
}
} else {
while (n-- != 0) {
char c1 = v1[i++];
char c2 = v2[j++];
if (c1 != c2) {
return c1 - c2;
}
}
}
return len1 - len2;
}

public int hashCode() {
int h = hash;
if (h == 0) {
int off = offset;
char val[] = value;
int len = count;

for (int i = 0; i < len; i++) {
h = 31*h + val[off++];
}
hash = h;
}
return h;
}
即：
s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1]

public String substring(int beginIndex, int endIndex) {
replace(char, char)
replace(CharSequence, CharSequence)
replaceAll(String, String)
replaceFirst(String, String)

StringBuffer 和 StringBuilder 的区别？ 我真不见得，，， 这考得太那个了吧!

public final class StringBuffer
extends AbstractStringBuilder
implements java.io.Serializable, CharSequence
主要api

StringBuffer()
StringBuffer(CharSequence)
StringBuffer(int)
StringBuffer(String)

append(char[])
append(char[], int, int)
append(CharSequence)
append(CharSequence, int, int)
append(double)
append(float)
append(int)
append(long)
append(Object)
append(String)
append(StringBuffer)
appendCodePoint(int)

reverse()

insert......

public final class StringBuilder
extends AbstractStringBuilder
implements java.io.Serializable, CharSequenceappend(char)

主要api
跟上面的一样，
不过没有reverse()

replace(int, int, String)

将 StringBuilder 的实例用于多个线程是不安全的。如果需要这样的同步，则建议使用 StringBuffer。
----- 仅仅是这儿区别吧！，确实，发现StringBuilder和StringBuffer大部分的方法签名实现等完全一样，只是StringBuffer的方法每个前面都有synchronized ！！

public
class StackOverflowError extends VirtualMachineError {
StackOverflowError()
StackOverflowError(String)

基本类似的包装类，大都是静态的方法，java实现，非native实现

Exception 是一个简单的类，仅仅只是提供了几个构造方法而已

Exception()
Exception(String)
Exception(String, Throwable)
Exception(Throwable)

Deprecated 是一个注解的接口，D大写
@Documented
@Retention(RetentionPolicy.RUNTIME)
public @interface Deprecated {
}

public final class Compiler {---------- 内部机制
command(Object)
compileClass(Class<?>)
compileClasses(String)
disable()
enable()
initialize()
registerNatives()
Compiler()

public abstract class ClassLoader {------- 是一个很重要的类，有一些内部实现

protected synchronized Class<?> loadClass(String name, boolean resolve)
throws ClassNotFoundException
{
// First, check if the class has already been loaded
Class c = findLoadedClass(name);
if (c == null) {
try {
if (parent != null) {
c = parent.loadClass(name, false);
} else {
c = findBootstrapClass0(name);
}
} catch (ClassNotFoundException e) {
// If still not found, then invoke findClass in order
// to find the class.
c = findClass(name);
}
}
if (resolve) {
resolveClass(c);
}
return c;
}

public final
class Class<T> implements java.io.Serializable,
java.lang.reflect.GenericDeclaration,
java.lang.reflect.Type,
java.lang.reflect.AnnotatedElement {

public static Class<?> forName(String className)
throws ClassNotFoundException {
return forName0(className, true, ClassLoader.getCallerClassLoader());
}

forName0 是内部实现---------- 以0结尾都这样？？？

======== java.lang.annotation ========
Annotation.java
AnnotationFormatError.java
AnnotationTypeMismatchException.java
Documented.java
ElementType.java
IncompleteAnnotationException.java
Inherited.java
Retention.java
RetentionPolicy.java
Target.java

java.lang.instrument
public final class ClassDefinition { ---- 干嘛的？

java.lang.ref ------ java引用

java.lang.reflect ----- java反射

package java.io

public class File
implements Serializable, Comparable<File>

abstract class FileSystem {

abstract class FileSystem {

/**
* Return the FileSystem object representing this platform‘s local
* filesystem.
*/
public static native FileSystem getFileSystem();

jdk研究——java.lang