java Thread ,Thread.currentThread().getName() 的含义 & 普通成员变量是何时被赋值的

java Thread ,Thread.currentThread().getName() 的含义

this得到的是当前的对象。java为一个对象创建一个线程运行，这个线程也可以理解为一个“对象”，通过 Thread.currentThread() 得到它的引用

Thread.currentThread(): Returns a reference to the currently executing thread object

Thread.currentThread() 调用时， 它在哪个线程里，就得到哪个线程的对象.

假设 一个线程类如下:<strong>Thread.currentThread().getName() 放在a处
那么它会在类 调用 new 构造方法的时候，详细看“普通成员变量是何时被赋值的” 被实例化，如果是在main中 new的 tname = main
</strong>

<pre name="code" class="html"><strong>Thread.currentThread().getName();放在b处</strong><span style="color:#FF0000;"><strong></strong></span>

<strong>那么它会在在  </strong>Consumer <strong>线程被 start 的时候调用，输出的就是 thread-0 云云</strong>

class Consumer implements Runnable{
private BreadStore breadstore = null;
<strong>//String tname = Thread.currentThread().getName();</strong> <span style="color:#FF0000;"><strong>a处</strong></span>
public Consumer(BreadStore breadstore){
this.breadstore = breadstore;
System.out.println("debug " + tname);
}

void get(String tname){
breadstore.get(tname);
}

public void run() {

while(true){
<pre name="code" class="html"><strong> //String tname = Thread.currentThread().getName();</strong> <span style="color:#FF0000;"><strong>b处</strong></span>  try {Thread.sleep(1000);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}get(tname);}}}

——————————普通成员变量是何时被赋值的  new的时候做了什么——————

总结：
Java语言里，new表达式总体负责两个动作：
分配对象空间并对其做默认初始化。默认初始化会将对象的所有成员字段设到其类型对应的默认值，解释：就是为各成员变量分配空间，再按代码顺序赋值
初始化对象

其中构造器只负责第2点，第1点是包含在new表达式里的语义，成员变量就是在第一点里分配实例化的。

eg1.

public class Test1 {
{
a = 1;
//System.out.println(a);//这里会抛错。
}
private int a=2;//这里初始化一次，上面的动态块中也对a进行了赋值，这个时候a=?，为什么可以对a进行赋值，而不可以对a进行输出
public static void main(String[] args){
Test1 test1 = new Test1();
System.out.println(test1.a);
}
}

看看上面的代码一，第一个问题就是这段代码能否编译通过。结果是能编译通过。这里说明一个问题就是变量的声明和赋值是两步操作？（这句话我先保留一半，在上面

的代码中有一行代码我注释掉了，这里会抛错，对于这个问题我也没有想明白为什么。）

第一个问题解决了。那下一个问题很显然最后输出的结果是什么？答案是“2”，这里可能会有些诧异。从直观上来讲就是说明在赋值的过程中是完全按照代码的前后顺序进

行。

eg2.

从Java SE 6开始是这样的：

public class MyClass {
private int a = 1; // field declaration with initializer

{
// instance initializer 1
a = 2;
}

public MyClass() {
// constructor
a = 4;
}

{
// instance initializer 2
a = 3;
}
}

这个MyClass的构造器从Java语言层面看就是public MyClass() { ... }的部分。不过对JVM来说所有实例初始化动作都要收集到“特殊的实例初始化方法”（名为“<init>”，内容对应所有实例初始化器+构造器）里，所以上面的代码从JVM的角度看会是这样：

public class MyClass {
private int a;

public void <init>() {
// implicit superclass constructor call
super();
// field initializer
a = 1;
// instance initializer 1
a = 2;
// instance initializer 2
a = 3;
// explicit constructor
a = 4;
}
}

这个合成的<init>()V里，先是构造器里隐式或显式的super()调用，然后是按代码顺序把实例初始化动作（包括实例字段初始化与匿名的实例初始化器）收集起来，然后是构造器自身的内容。

Java语言规范里对构造器中super()调用的位置的限制其实颇为鸡肋。一来可以通过上述方式通过写字段初始化或实例初始化器来在super()前执行代码，二来就算不用它们而只用普通的构造器也还是可以在super()前执行代码，只要super()可以接受至少一个参数——做法如下：

public class Derived extends Base {
public Derived() {
super(foo()); // assuming there's a Base(int) constructor
System.out.println("Derived ctor");
}

private int foo() {
System.out.println("foo!"); // arbitrary side effect
return 42;
}
}

只要基类有接受至少一个参数的构造器，子类的构造器在调用super()时就可以调用任意方法去提供那个参数的值，于是就可以在真的调用super()前产生任意的副作用了。