Think_in_java_4th（并发学习一）

java的并发是在顺序语言的基础上提供对线程的支持的。

并发能够更加有效的执行我们的代码，也就是更加合理的应用cpu资源。

并发程序往往cpu和内存使用率，要高于同等的非并发程序。

 下面就用think_in_java_4th，并发这个章节中源码简单说一下自己的认识。

liftoff.java

package concurrency;

//: concurrency/liftoff.java
// demonstration of the runnable interface.

public class liftoff implements runnable {
    protected int countdown = 10; // default
    private static int taskcount = 0;
    private final int id = taskcount++;

    public liftoff() {
    }

    public liftoff(int countdown) {
        this.countdown = countdown;
    }

    public string status() {
        return "#" + id + "(" + (countdown > 0 ? countdown : "liftoff!") + "), ";
    }

    public void run() {
        while (countdown-- > 0) {
            system.out.print(status());
            //线程调度器
            //将cpu从一个线程转移給另一个线程。
            thread.yield();
        }
    }
} /// :~

mainthread.java

package concurrency;

//: concurrency/mainthread.java

public class mainthread {
    public static void main(string[] args) {
        liftoff launch = new liftoff();
        launch.run();
    }
} /*
   * output: #0(9), #0(8), #0(7), #0(6), #0(5), #0(4), #0(3), #0(2), #0(1),
   * #0(liftoff!),
   */// :~

mainthread的执行结果和我们不使用多线程基本上没有什么区别。

package concurrency;

//: concurrency/basicthreads.java
// the most basic use of the thread class.

public class basicthreads {
    public static void main(string[] args) {
        thread t = new thread(new liftoff());
        t.start();
        system.out.println("waiting for liftoff");
    }
} /*
   * output: (90% match) waiting for liftoff #0(9), #0(8), #0(7), #0(6), #0(5),
   * #0(4), #0(3), #0(2), #0(1), #0(liftoff!),
   */// :~

thread 类使用后，我们可以看到。【"waiting for liftoff"】比【#0(9),...ff!),】更早被打印出来了。
此时，cpu和内存的使用情况就初步体现出来了。
new thread的jdk源码。
target（实现了runnable的类）最终被给了一个新的tid（nextthreadid）之后，加入到threadgroup中。

thread

    public thread(runnable target) {
        init(null, target, "thread-" + nextthreadnum(), 0);
    }

    private void init(threadgroup g, runnable target, string name,
                      long stacksize, accesscontrolcontext acc) {
。。。。。。
        g.addunstarted();
。。。。。。
        this.target = target;
        setpriority(priority);
        if (parent.inheritablethreadlocals != null)
            this.inheritablethreadlocals =
                threadlocal.createinheritedmap(parent.inheritablethreadlocals);
        /* stash the specified stack size in case the vm cares */
        this.stacksize = stacksize;

        /* set thread id */
        tid = nextthreadid();
}

 好了，我们大概知道new thread 的过程了。此处应该有图，哈哈。偷个懒。

也就是说，在【new thread(new liftoff())】被给予新的tid并加入到threadgroup的时候，system.out执行了。

并且，system.out没有等待【t.start();】的执行完，再开始执行。

这样的结果就是因为，主线程和子线程并发执行的结果。

这时，【在顺序语言的基础上提供对线程的支持】句话就可以拿出来再理解一下了。

 

thread

 

    public synchronized void start() {
......
        /* notify the group that this thread is about to be started
         * so that it can be added to the group's list of threads
         * and the group's unstarted count can be decremented. */
        group.add(this);
......
}

 

threadgroup

    void add(thread t) {
......
            nunstartedthreads--;
......
}

morebasicthreads.java

 

package concurrency;

//: concurrency/morebasicthreads.java
// adding more threads.

public class morebasicthreads {
    public static void main(string[] args) {
        for (int i = 0; i < 5; i++)
            new thread(new liftoff()).start();
        system.out.println("waiting for liftoff");
    }
} /*
   * output: (sample) waiting for liftoff #0(9), #1(9), #2(9), #3(9), #4(9),
   * #0(8), #1(8), #2(8), #3(8), #4(8), #0(7), #1(7), #2(7), #3(7), #4(7), #0(6),
   * #1(6), #2(6), #3(6), #4(6), #0(5), #1(5), #2(5), #3(5), #4(5), #0(4), #1(4),
   * #2(4), #3(4), #4(4), #0(3), #1(3), #2(3), #3(3), #4(3), #0(2), #1(2), #2(2),
   * #3(2), #4(2), #0(1), #1(1), #2(1), #3(1), #4(1), #0(liftoff!), #1(liftoff!),
   * #2(liftoff!), #3(liftoff!), #4(liftoff!),
   */// :~

 

#0(9), #0(8), #0(7), #0(6), #0(5), #0(4), #0(3), #1(9), #2(9), #1(8), #0(2), #3(9), #1(7), waiting for liftoff
#3(8), #3(7), #3(6), #3(5), #3(4), #3(3), #3(2), #3(1), #3(liftoff!), #1(6), #1(5), #1(4), #1(3), #1(2), #1(1), #1(liftoff!), #2(8), #2(7), #2(6), #2(5), #2(4), #2(3), #2(2), #2(1), #2(liftoff!), #0(1), #4(9), #0(liftoff!), #4(8), #4(7), #4(6), #4(5), #4(4), #4(3), #4(2), #4(1), #4(liftoff!), 

创建多个线程，并启动。

实际上，线程的创建销毁是非常快的。当一个线程完成了它的任务的时候，该线程占有的资源就会被释放。

那么我们就又可以把已经释放的资源用于创建其他新的线程了。

 

参考

java编程思想(第4版)    654页开始

thinking in java（第四版 ）  1116页开始