OBJECT ORIENTED

Mon, 01 Jan 0001 00:00:00 +0000

对象结构 #
- 对象头 #
  - Mark Word #
    
    Mark Word(标记字)，用于存储自身运行时的数据例如GC标志位、哈希码、锁状态等信息。Mark Word 的位长度为 JVM 的一个 Word 大小，也就是说 32 位 JVM 的 Mark word 为 32 位，64 位 JVM 为 64 位。Mark Word 的位长度不会受到 Oop 对象指针压缩选项的影响。
    
    结构信息：
    Java 内置锁的涉及到很多重要信息，并且是存放于对象头的 Mark Word 字段中。
    
    Java 内置锁的状态总共有四种，级别由低到高依次为:无锁、偏向锁、轻量级锁、重量级锁。为了让 Mark word 字段存储更多的信息，JVM 将 Mark word 的最低两个位设置为 Java 内置锁状态位。
    
    其实在 JDK 1.6 之前，Java 内置锁还是一个重量级锁，是一个效率比较低下的锁，在 JDK 1.6 之后，JVM 为了提高锁的获取与释放效率，对 synchronized 的实现进行了优化，引入了偏向锁、轻量级锁的实现，从此以后 Java 内置锁的状态就有了四种(无锁、偏向锁、轻量级锁、重量级锁)，并且四种状态会随着竞争的情况逐渐升级，而且是不可逆的过程，即不可降级，也就是说只能进行锁升级(从低级别到高级别)。

Mon, 01 Jan 0001 00:00:00 +0000

AQS 内部结构 #

内部类Node节点代码

代码示例

static final class Node {
 /** Marker to indicate a node is waiting in shared mode */
 static final Node SHARED = new Node();
 /** Marker to indicate a node is waiting in exclusive mode */
 static final Node EXCLUSIVE = null;

 /** waitStatus value to indicate thread has cancelled */
 static final int CANCELLED = 1;
 /** waitStatus value to indicate successor's thread needs unparking */
 static final int SIGNAL = -1;
 /** waitStatus value to indicate thread is waiting on condition */
 static final int CONDITION = -2;
 /**
 * waitStatus value to indicate the next acquireShared should
 * unconditionally propagate
 */
 static final int PROPAGATE = -3;

 /**
 * Status field, taking on only the values:
 * SIGNAL: The successor of this node is (or will soon be)
 * blocked (via park), so the current node must
 * unpark its successor when it releases or
 * cancels. To avoid races, acquire methods must
 * first indicate they need a signal,
 * then retry the atomic acquire, and then,
 * on failure, block.
 * CANCELLED: This node is cancelled due to timeout or interrupt.
 * Nodes never leave this state. In particular,
 * a thread with cancelled node never again blocks.
 * CONDITION: This node is currently on a condition queue.
 * It will not be used as a sync queue node
 * until transferred, at which time the status
 * will be set to 0. (Use of this value here has
 * nothing to do with the other uses of the
 * field, but simplifies mechanics.)
 * PROPAGATE: A releaseShared should be propagated to other
 * nodes. This is set (for head node only) in
 * doReleaseShared to ensure propagation
 * continues, even if other operations have
 * since intervened.
 * 0: None of the above
 *
 * The values are arranged numerically to simplify use.
 * Non-negative values mean that a node doesn't need to
 * signal. So, most code doesn't need to check for particular
 * values, just for sign.
 *
 * The field is initialized to 0 for normal sync nodes, and
 * CONDITION for condition nodes. It is modified using CAS
 * (or when possible, unconditional volatile writes).
 */
 volatile int waitStatus;

 /**
 * Link to predecessor node that current node/thread relies on
 * for checking waitStatus. Assigned during enqueuing, and nulled
 * out (for sake of GC) only upon dequeuing. Also, upon
 * cancellation of a predecessor, we short-circuit while
 * finding a non-cancelled one, which will always exist
 * because the head node is never cancelled: A node becomes
 * head only as a result of successful acquire. A
 * cancelled thread never succeeds in acquiring, and a thread only
 * cancels itself, not any other node.
 */
 volatile Node prev;

 /**
 * Link to the successor node that the current node/thread
 * unparks upon release. Assigned during enqueuing, adjusted
 * when bypassing cancelled predecessors, and nulled out (for
 * sake of GC) when dequeued. The enq operation does not
 * assign next field of a predecessor until after attachment,
 * so seeing a null next field does not necessarily mean that
 * node is at end of queue. However, if a next field appears
 * to be null, we can scan prev's from the tail to
 * double-check. The next field of cancelled nodes is set to
 * point to the node itself instead of null, to make life
 * easier for isOnSyncQueue.
 */
 volatile Node next;

 /**
 * The thread that enqueued this node. Initialized on
 * construction and nulled out after use.
 */
 volatile Thread thread;

 /**
 * Link to next node waiting on condition, or the special
 * value SHARED. Because condition queues are accessed only
 * when holding in exclusive mode, we just need a simple
 * linked queue to hold nodes while they are waiting on
 * conditions. They are then transferred to the queue to
 * re-acquire. And because conditions can only be exclusive,
 * we save a field by using special value to indicate shared
 * mode.
 */
 Node nextWaiter;

 /**
 * Returns true if node is waiting in shared mode.
 */
 final boolean isShared() {
 return nextWaiter == SHARED;
 }

 /**
 * Returns previous node, or throws NullPointerException if null.
 * Use when predecessor cannot be null. The null check could
 * be elided, but is present to help the VM.
 *
 * @return the predecessor of this node
 */
 final Node predecessor() throws NullPointerException {
 Node p = prev;
 if (p == null)
 throw new NullPointerException();
 else
 return p;
 }

 Node() { // Used to establish initial head or SHARED marker
 }

 Node(Thread thread, Node mode) { // Used by addWaiter
 this.nextWaiter = mode;
 this.thread = thread;
 }

 Node(Thread thread, int waitStatus) { // Used by Condition
 this.waitStatus = waitStatus;
 this.thread = thread;
 }
}

整体结构图

Mon, 01 Jan 0001 00:00:00 +0000

java 中异常返回时机 #

example #

// finally语句在return语句执行之后return返回之前执行的
public int exp1(){
 int b = 20;
 try {
 System.out.println("try block");
 return b += 80;
 }
 catch (Exception e) {
 System.out.println("catch block");
 }
 finally {
 System.out.println("finally block");
 if (b > 25) {
 System.out.println("b>25, b = " + b);
 }
 }
 return b;
}

output:
try block
finally block
b>25, b = 100
100

// finally块中的return语句会覆盖try块中的return返回
public int exp2() {
 int b = 20;
 try {
 System.out.println("try block");
 return b += 80;
 } catch (Exception e) {
 System.out.println("catch block");
 } finally {
 System.out.println("finally block");
 if (b > 25) {
 System.out.println("b>25, b = " + b);
 }
 return 200;
 }
 // return b;
}

output:
try block
finally block
b>25, b = 100
200

// 如果finally语句中没有return语句覆盖返回值，那么原来的返回值可能因为finally里的修改而改变也可能不变
public int exp3() {
 int b = 20;
 try {
 System.out.println("try block");
 return b += 80;
 } catch (Exception e) {
 System.out.println("catch block");
 } finally {
 System.out.println("finally block");
 if (b > 25) {
 System.out.println("b>25, b = " + b);
 }
 b = 150;
 }
 return 2000;
}

output:
try block
finally block
b>25, b = 100
100

public Map<String, String> exp3_1() {
 Map<String, String> map = new HashMap();
 map.put("KEY", "INIT");
 try {
 map.put("KEY", "TRY");
 return map;
 }
 catch (Exception e) {
 map.put("KEY", "CATCH");
 }
 finally {
 map.put("KEY", "FINALLY");
 map = null;
 }
 return map;
}

output:
FINALLY

// try块里的return语句在异常的情况下不会被执行(参考中的例子有错误)
public int exp4() {
 int b = 20;
 try {
 System.out.println("try block");
 b = b / 0;
 return b += 80;
 } catch (Exception e) {
 b += 15;
 System.out.println("catch block");
 } finally {
 System.out.println("finally block");
 if (b > 25) {
 System.out.println("b>25, b = " + b);
 }
 b += 50;
 }
 return 204;
}

output:
try block
catch block
finally block
b>25, b = 35
204

// 当发生异常后，catch中的return执行情况与未发生异常时try中return的执行情况完全一样
public int exp5() {
 int b = 20;
 try {
 System.out.println("try block");
 b = b /0;
 return b += 80;
 } catch (Exception e) {
 System.out.println("catch block");
 return b += 15;
 } finally {
 System.out.println("finally block");
 if (b > 25) {
 System.out.println("b>25, b = " + b);
 }
 b += 50;
 }
 //return b;
}

output:
try block
catch block
finally block
b>25, b = 35
35

// catch中的return先计算然后传值到finally中最后finally直接返回，也符合情况1。
public int exp6() {
 int b = 20;
 try {
 System.out.println("try block");
 b = b /0;
 return b += 80;
 } catch (Exception e) {
 System.out.println("catch block");
 return b += 15;
 } finally {
 System.out.println("finally block");
 if (b > 25) {
 System.out.println("b>25, b = " + b);
 }
 return b += 50;
 }
 //return b;
}

output:
try block
catch block
finally block
b>25, b = 35
85

字节码查看异常执行顺序 #

reference #

Mon, 01 Jan 0001 00:00:00 +0000

TCP #
UDP #
InetAddress #
- 流程解析 #
  
  根据域名实例化一个InetAddress对象的流程解析。
  比如：InetAddress byName = InetAddress.getByName("wtfu.site");。如果是域名的话，会涉及到系统调用getaddrinfo.里面包括DNS解析。
  
  1. getAllByName(String host, InetAddress reqAddr)
  2. 不属于ip地址的话，会继续进入到getAllByName0()
  3. addresses = getAddressesFromNameService(host, reqAddr);
  4. addresses = nameService.lookupAllHostAddr(host);
  5. impl.lookupAllHostAddr(host); // impl为Inet6AddressImpl类型，且lookupAllHostAddr为native方法。
  6. 定位到c源码后如下：可以看到关键的getaddrinfo系统调用。
```
//src/java.base/unix/native/libnet/Inet6AddressImpl.c
JNIEXPORT jobjectArray JNICALL
Java_java_net_Inet6AddressImpl_lookupAllHostAddr(JNIEnv *env, jobject this,
 jstring host, jint characteristics) {
 error = getaddrinfo(hostname, NULL, &hints, &res);
}
```
- 测试系统调用流程 #
  1. 编写样例代码

Mon, 01 Jan 0001 00:00:00 +0000

Intro(String) #

内存布局 #

intern() #

String.intern()方法表示获取一个字符串对象的值在常量池中的引用。如果常量池中存在，则直接返回引用。如果不存在，常量池创建并返回引用。

不同jdk版本创建并返回引用是有区别的：
JDK1.6，不存在则在永久代字符串常量池创建等值字符串，
JDK1.6之后，在堆区字符串常量池创建的是堆中String obj的引用。参考1，参考2

另外字符串常量池的实现是 C++ 中的hashtable。

String s = new String("ABC") 这行单纯代码层面来说，只创建一个对象。如果包含类加载的过程，有可能会创建两个，一个在常量池中，一个在堆里面。堆里面的引用常量池中的value。参考

不要使用JUnit之类的工具测试intern方法，有可能会有误差，详细解释查看case3

/**
 * Returns a canonical representation for the string object.
 * <p>
 * A pool of strings, initially empty, is maintained privately by the
 * class {@code String}.
 * <p>
 * When the intern method is invoked, if the pool already contains a
 * string equal to this {@code String} object as determined by
 * the {@link #equals(Object)} method, then the string from the pool is
 * returned. Otherwise, this {@code String} object is added to the
 * pool and a reference to this {@code String} object is returned.
 * <p>
 * It follows that for any two strings {@code s} and {@code t},
 * {@code s.intern() == t.intern()} is {@code true}
 * if and only if {@code s.equals(t)} is {@code true}.
 * <p>
 * All literal strings and string-valued constant expressions are
 * interned. String literals are defined in section 3.10.5 of the
 * <cite>The Java&trade; Language Specification</cite>.
 *
 * @return a string that has the same contents as this string, but is
 * guaranteed to be from a pool of unique strings.
 */
public native String intern();

测试 #

// source: https://blog.csdn.net/tyyking/article/details/82496901
String str2 = new String("str") + new String("01");
str2.intern(); 
String str1 = "str01";
System.out.println(str2 == str1);

// 上述代码在JDK1.6及以后版本表现不同。假设str2的地址为`String@725`
// 1.6 调用`str2.intern()`会在永久代字符串常量池中复制等值字符串String@825，然后返回引用String@825。给str1赋值的时候发现字符串常量池有'str01'，则将引用String@825给str1。
// >1.6 调用`str2.intern()`会在堆区字符串常量池中放置对象str2的引用String@725，然后返回引用String@725。给str1赋值的时候发现字符串常量池有'str01'，则将引用String@725给str1。

archive

OBJECT ORIENTED

对象结构 #

对象头 #

Mark Word #

AQS 内部结构 #

java 中异常返回时机 #

example #

字节码查看异常执行顺序 #

reference #

TCP #

UDP #

InetAddress #

流程解析 #

测试系统调用流程 #

Intro(String) #

内存布局 #

intern() #

测试 #