再问：学了线程之后，却不知this究竟是什么了

Question

这个帖子本来觉得明白了，可后来细想，还是不明白。
一个测试当前处于哪个线程的小例子，在printMsg方法里，第二个条件t==this，可以判断出当该方法被该类的新线程调用时的情况，这我就不明白了，this本是指明当前类的实例的，怎么又成了一个线程了。运行的结果却证实了这一点。
package test;/**
 * Created by IntelliJ IDEA.
 * User: Administrator
 * Date: 2006-1-5
 * Time: 22:44:08
 * To change this template use File | Settings | File Templates.
 */
public class TwoThread extends Thread{
    private  Thread creatorThread;    public TwoThread() {
        this.creatorThread = Thread.currentThread();
    }    public void run() {
        for (int i = 0; i < 10; i++) {
              printMsg();        }
    }
public void printMsg(){
        Thread t=Thread.currentThread();
        if (t==creatorThread){
            System.out.println("创建者线程");
        }else if(t==this){
            System.out.println("新线程");
        } else{
            System.out.println("不知道的线程");
        }
    }
    public static void main(String args[]){
          TwoThread tt=new TwoThread();
        tt.start();
        for (int i = 0; i < 10; i++) {
          tt.printMsg();
        }
        }
}运行结果：
创建者线程
创建者线程
创建者线程
创建者线程
创建者线程
创建者线程
创建者线程
创建者线程
创建者线程
创建者线程
新线程
新线程
新线程
新线程
新线程
新线程
新线程
新线程
新线程
新线程对象和线程是独立的两个东西，任何对象都是由线程来管理，在线程里运行的。所以，我觉得t==this怎么能和当前实例是同一个对象呢，尽管当前对象是一个Thread的子类，但它也是对象，是对象就是在线程里去运行的，不能说一个线程在另一个线程里运行吧，那就乱套了。

Answer 1

main本身是一个线程，可能是虚拟机对象？
TwoThread tt=new TwoThread();产生另一线程对象tt，创建者是main线程。
你加了Thread t=Thread.currentThread();这句就是取得了进入了当前方法的线程对象啊，有什么不对的？Java线程本身就是一个Thread对象啊。不明白的话看看这个
package test;public class TwoThread extends Thread {
    private Thread creatorThread;    public TwoThread() {
        this.creatorThread = Thread.currentThread();
    }    public void run() {
        System.out.println("新建的线程对象名字："+Thread.currentThread().getName());
        for (int i = 0; i < 10; i++) {
            printMsg();
        }
    }    public void printMsg() {
        Thread t = Thread.currentThread();
        System.out.println("当前线程对象名字："+t.getName());
        if (t == creatorThread) {
            System.out.println("创建者线程");
        } else if (t == this) {
            System.out.println("新线程");
        } else {
            System.out.println("不知道的线程");
        }
    }    public static void main(String args[]) {
        System.out.println("main线程对象名字："+Thread.currentThread().getName());
        TwoThread tt = new TwoThread();
        tt.start();
        for (int i = 0; i < 10; i++) {
            tt.printMsg();
        }
    }
}运行结果：main线程对象名字：main
当前线程对象名字：main
创建者线程
当前线程对象名字：main
创建者线程
当前线程对象名字：main
创建者线程
当前线程对象名字：main
创建者线程
当前线程对象名字：main
创建者线程
当前线程对象名字：main
创建者线程
当前线程对象名字：main
创建者线程
当前线程对象名字：main
创建者线程
当前线程对象名字：main
创建者线程
当前线程对象名字：main
创建者线程
新建的线程对象名字：Thread-0
当前线程对象名字：Thread-0
新线程
当前线程对象名字：Thread-0
新线程
当前线程对象名字：Thread-0
新线程
当前线程对象名字：Thread-0
新线程
当前线程对象名字：Thread-0
新线程
当前线程对象名字：Thread-0
新线程
当前线程对象名字：Thread-0
新线程
当前线程对象名字：Thread-0
新线程
当前线程对象名字：Thread-0
新线程
当前线程对象名字：Thread-0
新线程

Answer 2

哈哈！楼主你应该这样理解：
线程的执行也是有语句实现的，我们写这些语句都要在一个线程里执行，就像在main方法里执行语句一样，它是在主线程里执行。
TwoThread tt = new TwoThread();//这一句表明把tt.creatorThread = 主线程
而tt.start();//则是在main里有重新启动了一个线程tt，tt线程是脱离主线程来执行的
当进入printMsg里以后，如果执行的当前线程是：tt，显示的结果就是：新线程
                      如果执行的当前线程是：main，显示的结果就是：创建者线程
我不知道这样说楼主明白不明白？

Answer 3

主线程明白。但t==this不明白，楼上还是不太明白我的意思。

Answer 4

public static void main(String args[]){
TwoThread tt=new TwoThread();
tt.start();
for (int i = 0; i < 10; i++) {
tt.printMsg();
}你注意到这里，tt.start启动的是新构造的线程，这个线程使用构造函数public TwoThread() {
this.creatorThread = Thread.currentThread();}此时给creatorThread赋值的是这个新构建的线程，其打印；执行完run后，接着执行，这个时间执行的是main线程，即jvm执行static方法的线程，此时再打印的时候，当然不是刚刚刚刚通过构造方法创建的线程喽

Answer 5

this本是指明当前类的实例的，怎么又成了一个线程了当前类不就是一个线程类吗?

Answer 6

this的概念不管用在哪类对象身上都是一样,用在线程上边当然也一样.

Answer 7

this不就是类本身吗？
和delphi的self一样

Answer 8

这个类是继承Thread的,所以this代表这类创建的新线程

Answer 9

to rnwoxn:
  没错，这个类的实例是一个线程，但它也是个对象，对象总是被线程所管理，运行在一个线程里，如果按你说的，它是个线程对象，this就代表线程，那它运行在哪里？运行在自己里面？那就成了线程运行在线程里，所以我很糊涂。一个对象可能一会被这个线程调用，一会儿被那个线程调用。总不能被自身调用吧。

Answer 10

你最好按照原来的理解,不管怎么样,this始终是属于类对象的引用,说白了就是简化了构造函数.

Answer 11

楼主不要把线程想得太神秘,线程本质还是对相,有类成员,类方法,有存储数据的空间,既线程对象,至如它运行在哪里,是由MV来调度.线程间的传值就相类之间的传值一样,只不过线程有其特性,线,你说线程自已调用自已这有何不可,只不过是死循还而已,没意义.如加上:    public void run() {
        System.out.println("新建的线程对象名字："+Thread.currentThread().getName());
        for (int i = 0; i < 10; i++) {
            printMsg();
        }
        invokeSelf();
    }
    public void invokeSelf(){
        new TwoThread().run();
       
    }

Answer 12

本来偶也是有点迷糊,但看了一楼:zncn2(embedded system)的说法就清楚了.有几点要澄清的:1.main()是主线程,只要在其中运行另一个线程对象,那么两个线程就达到"并行"的意义了.但main的优先权并不特殊.2.这里main中的循环for这里由于JVM调度先于tt.start()--->>>run()的执行[但不能确保始终如一,你可以在printMsg()最尾一行加Thread.yield()观察两者"并行"的意义,但比较复杂.]所以输出其实是两者反了的,不要以为前十个循环是由tt运行所至!!!3.Thread.currentThread()就是当前正在运行中的线程.而tt.printMsg()这时tt线程是没有运行的,此时可看作是一个当前实例而已(对象.实方法).对于方法就是已经进入了该方法的线程.还不够白的话,看看API:Returns a reference to the currently executing Thread object.希望有所帮助,大家交流哦!^v^

Answer 13

各位还是没有明白我的意思，我有必要再重申五，程序中t==this，代表当前线程是新线程的情况，但this是TwoThread的实例，怎么成了一个线程？虽然它本身是个线程类，但对象和线程是两个独立的东西吧，我理解为汽车和公路的关系，一辆汽车可以在不同的道路上跑，每个道路就是一个线程，因此，this不能代表线程，它只代表当前对象的实例，不管这个类究竟是不是线程类,它是被运行在一个线程中的，至于线程究竟是个什么玩意，我就不知道了。至于什么并行执行，优先级的问题，不是我的问题。this指的是车，不是道路。不知我这样说，你们明白没有。

Answer 14

长见识,学习学习,我想能不能这样想,JVM中线程是正在运行的一个类的实力(Thread的子类),那么,t得到当前的运行对象,this是指向当前的对象,有什么不对?

Answer 15

现在再看一下你的代码,首先看 TwoThread tt=new TwoThread();创建了一个对象,再看代码:
 this.creatorThread = Thread.currentThread();这时当前进程是谁,是main,然后 tt.start();
创建一个线程,接着main继续执行就出现了
创建者线程
接着tt继续运行,就出现了
新线程,
楼主看这样解释是不是恰些当

Answer 16

云!JAVA中:一切都是对象!OOP!线程是动态的,火车是程序的话.列车就是线程
t是一个引用,this当然是一个当前对象的引用.可以比较.

Answer 17

to Javan05s:
  没错，一切都是对象，t代表着当前运行的线程，但this只是一个类的实例呀，尽管这里比较特殊,类就是一个线程类,但仍然是对象,是线程中运行的东西，不是线程本身吧，线程我理解是一个对象运行的环境。要不然，为什么一个对象的方法既可以被自己的线程调用，也可以被main线程或是其它线程调用呢

Answer 18

引：
对象和线程是独立的两个东西，任何对象都是由线程来管理，在线程里运行的。所以，我觉得t==this怎么能和当前实例是同一个对象呢，尽管当前对象是一个Thread的子类，但它也是对象，是对象就是在线程里去运行的，不能说一个线程在另一个线程里运行吧，那就乱套了。解：
t值的是当前线程，this指的是当前实例对象
而当前实例对象正好就是一个线程（当前线程）
顺理成章的t就=this了

Answer 19

tt是继承Thread的当然也是个线程了

Answer 20

t = Thread.currentThread()返回当前运行的线程对象（thread object），this指向一个TwoThread（Thread子类）对象，也是一个线程对象（thread object）。所以t和this是相同的类型，具有可比性。可能关键还是在于这个this引用到底是怎么确定的，是在不同的运行中（线程中）确定的？还是在用构造函数生成对象时就已经定死了的？个人觉得在多线程运行环境中，this指向的是每个具体的TwoThread线程对象，而不是所有线程一个统一的TwoThread对象。

Answer 21

另外，如果不执行tt.start()，则系统中只有一个main主线程对象，并没有运行中的TwoThread线程对象，如下所示：/**
* @author Hill
*/
public class TwoThread3 extends Thread {
public TwoThread3() {
//this.creatorThread = Thread.currentThread();
}public void run() {
for (int i = 0; i < 10; i++) {
printMsg();
}
}public void printMsg() {
Thread t = Thread.currentThread();
//t指向当前运行的main线程对象，this指向当前TwoThread3线程对象
if (t == this) {
System.out.println("当前运行线程是TwoThread3线程");
} else {
System.out.println("不是TwoThread3线程（其实是main线程）");
}
}public static void main(String[] args) {
TwoThread3 tt = new TwoThread3();
//tt.start();
for (int i = 0; i < 10; i++) {
tt.printMsg();
}
}
}

Answer 22

在这里,this表示的是一个TwoThread对象,TwoThread类是Thread的子类,所以也是一个Thread线程对象
Thread.currentThread()返回当前正在运行的线程对象,它可能是main线程,也可能是你创建的新线程

Answer 23

Java使用了Thread类封装了所谓“线程”的功能，Thread对象并不是纯粹意义上的“线程”概念。纯粹意义上的“线程”概念应该是指“公路”，而Java中的“线程”（通过Thread类实现的线程）就是“汽车”，是指在路上开着的汽车。每辆汽车都会有一个单独的this指针的。以上是个人猜想的观点＾＿＾

Answer 24

to zngj:
  照你的意思，TwoThread的实例对象，是运行在自己生成的线程里，自己管理自己的对象的运行，这看上去比较费解啊。好像一个人既是自己，又是自己的爸爸。

Answer 25

public TwoThread() {
        this.creatorThread = Thread.currentThread();
    }
在TwoThread() 里面这个Thread.currentThread()返回的到底是tt还是main的线程？
从结果看，应该是tt线程才对，也就是tt.creatorThread==tt
不过这样看来是tt创建了自己？晕了

Answer 26

creatorThread 是主线程－－－main线程，因为是main线程创建它的，构造函数只调用一次，怎么会是tt创建了自己。

Answer 27

那么我也再答,你在tt.start后加上 join()等它执行完再看public class TwoThread extends Thread{
    private  Thread creatorThread;    public TwoThread() {
        this.creatorThread = Thread.currentThread();
    }    public void run() {
        for (int i = 0; i < 10; i++) {
              printMsg();        }
    }
public void printMsg(){
        Thread t=Thread.currentThread();
        if (t==creatorThread){
            System.out.println(this.getClass().getName() + " creatorThread 创建者线程");
        }else if(t==this){
            System.out.println(this.getClass().getName() + " TwoThread 新线程");
        } else{
            System.out.println("不知道的线程");
        }
    }
    public static void main(String args[]){
          TwoThread tt=new TwoThread();
        tt.start();
        try{
        tt.join();
        }
        catch(Exception ex){
        ex.printStackTrace();
        }
        for (int i = 0; i < 10; i++) {
          tt.printMsg();
        }
        }
}输出：
TwoThread TwoThread 新线程
TwoThread TwoThread 新线程
TwoThread TwoThread 新线程
TwoThread TwoThread 新线程
TwoThread TwoThread 新线程
TwoThread TwoThread 新线程
TwoThread TwoThread 新线程
TwoThread TwoThread 新线程
TwoThread TwoThread 新线程
TwoThread TwoThread 新线程
TwoThread creatorThread 创建者线程
TwoThread creatorThread 创建者线程
TwoThread creatorThread 创建者线程
TwoThread creatorThread 创建者线程
TwoThread creatorThread 创建者线程
TwoThread creatorThread 创建者线程
TwoThread creatorThread 创建者线程
TwoThread creatorThread 创建者线程
TwoThread creatorThread 创建者线程
TwoThread creatorThread 创建者线程

Answer 28

线程应该是在start()调用或是run()方法执行才开始一个新的线程的.而Thread类应该是封装了线程,但它是一个类,不是单纯的线程

Answer 29

我也是刚学到线程,哈,你的问题挺有意思的,看了楼上这些高人的讲解,我觉得this 就是TwoThread这个线程,当程序运行main函数时,
TwoThread tt=new TwoThread();
tt.start();
创建一个新线程,开始运行TwoThread中的 run方法,由于构造函数
public TwoThread() {
        this.creatorThread = Thread.currentThread();
    }
所以tt==creatorThread即为当前的线程,运行
 if (t==creatorThread){
            System.out.println("创建者线程");
又由于FOR循环
public void run() {
        for (int i = 0; i < 10; i++) {
              printMsg();
,10次后,printMsg();结束,开始接着运行主函数中的FOR循环,
 public static void main(String args[]){
          TwoThread tt=new TwoThread();
        tt.start();
        for (int i = 0; i < 10; i++) {
          tt.printMsg();
        }
而此时的tt所赋的值为线程是TwoThread(因为刚才运行run方法),所以此时FOR中运行
else if(t==this){
            System.out.println("新线程");
我就这点想法,不知道对不对,也不知道描述的清不清楚,我已经尽力了呀,

Answer 30

这个类是继承Thread的,所以this代表这类创建的新线程