Java并发之Thread

class MyThread extends Thread{
    public MyThread(String name) {
        super(name);
    }

    public void run(){
        System.out.println(Thread.currentThread().getName()+" is running");
    }
};

public class Demo {
    public static void main(String[] args) {
        Thread mythread=new MyThread("mythread");

        System.out.println(Thread.currentThread().getName()+" call mythread.run()");
        mythread.run();

        System.out.println(Thread.currentThread().getName()+" call mythread.start()");
        mythread.start();
    }  
}
/* ------out put ---------
 * main call mythread.run()
 * main is running
 * main call mythread.start()
 * mythread is running
 */

    Thread thread = new Thread(){
            @Override
            public void run(){
                while(true) {
                    int tmp = (int) System.currentTimeMillis() / 1000;
                    user.setId(tmp);
                    try {
                        Thread.sleep(99);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    user.setName(String.valueOf(tmp));
                }
            }
        };
        thread.start();
        Thread.sleep(100);
        thread.stop();
        System.out.println(user);
//-----------------------
//user -> [ id = -1064621, name = 0 ]

public class StopThread {

    public static User user = new User();

    public static class Reader implements Runnable{
        public void run() {
            while(true) {
                synchronized (StopThread.class) {
                    if (user.getId()!= Integer.parseInt(user.getName())) {
                        System.out.println(user);
                    }
                }
                Thread.yield();
            }
        }
    }

    public static class Writer implements Runnable{
        public void run() {
            while (true){
                synchronized (StopThread.class){
                    int tmp = (int) System.currentTimeMillis()/1000;
                    user.setId(tmp);
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    user.setName(String.valueOf(tmp));
                }
                Thread.yield();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        new Thread(new Reader()).start();
        while(true) {
            Thread thread = new Thread(new Writer());
            thread.start();
            Thread.sleep(150);
            thread.stop();
        }
    }
}

public class InterruptThread {

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(){
            @Override
            public void run() {
                while(true) {
                    // 此处处理正常loop 时的中断
                    if(Thread.currentThread().isInterrupted()){
                        System.out.println("Thread is Interrupted!");
                        break; // 调出循环
                    }
                    System.out.println("Thread is Running!");
                    try {
                        // 如果此时中断，会触发 InterruptedException
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        // 阻塞时被中断
                        // 1. 需要设置下中断状态，以便下次正常loop执行时跳出执行
                        // 2. 也可以直接抛到外层，由外层处理(不推荐)
                        Thread.currentThread().interrupt();
                        e.printStackTrace();
                    }
                    Thread.yield();
                }
            }
        };

        thread.start();
        Thread.sleep(5000);
        System.out.println("interrupt Thread!");
        thread.interrupt();
    }
}

public class waitandnotify {
    private final  Object lock = new Object();
    public class T1 extends Thread{
        @Override
        public void run(){
            System.out.println(System.currentTimeMillis()+ "-> T1 start() ");
            synchronized (lock){
                System.out.println(System.currentTimeMillis()+ "-> T1 begin wait() ");
                try {
                    lock.wait();
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
                System.out.println(System.currentTimeMillis()+ "-> T1 end wait() ");
            }
        }
    }
    public class T2 extends Thread{
        @Override
        public void run(){
            System.out.println(System.currentTimeMillis()+ "-> T2 start() ");
            synchronized (lock){
                System.out.println(System.currentTimeMillis()+ "-> T2 begin notify() ");
                lock.notify();
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
                System.out.println(System.currentTimeMillis()+ "-> T2 end notify() ");
            }
        }
    }

    public static void main(String[] args){
        waitandnotify client = new waitandnotify();
        Thread t1 = client.new T1();
        Thread t2 = client.new T2();
        t1.start();
        t2.start();
    }
}
/*1502699128356-> T1 start() 
 *1502699128356-> T1 begin wait() 
 *1502699128356-> T2 start() 
 *1502699128356-> T2 begin notify() 
 *1502699133357-> T2 end notify() 
 *1502699133357-> T1 end wait() 
 */

public class suspend_resume {

    public static class ChangeThread1 extends Thread{
        private  int i= 0;
        public void run() {
            while (true) {
                    System.out.println(System.currentTimeMillis() + "-> Thread ::" + ++i);
            }
        }
    }
    public static void main(String[] args) throws InterruptedException {

        ChangeThread1 thread1 = new ChangeThread1();
        thread1.start();
        Thread.sleep(100);
        System.out.println(System.currentTimeMillis()+"------begin-----suspend ");
        thread1.suspend();
        Thread.sleep(10);
        thread1.resume();
        System.out.println(System.currentTimeMillis()+"-------end-----resume ");
        thread1.suspend();
    }
}

public class suspend_resume_dead_lock {

    public static Object lock = new Object();

    public static class ChangeObjectThread extends Thread{
        public ChangeObjectThread(String name) {
            super(name);
        }

        @Override
        public void run() {
            System.out.println(System.currentTimeMillis()+" -> "+this.getName()+"======= begin ======");
            synchronized (lock){
                System.out.println(System.currentTimeMillis()+" -> "+this.getName()+"+++++++ enter lock ++++++");
                Thread.currentThread().suspend();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        ChangeObjectThread thread1 = new ChangeObjectThread("thread1");
        thread1.start();
        Thread.sleep(100);
        System.out.println(System.currentTimeMillis()+" -> ######### sleep 100 ##########");
        ChangeObjectThread thread2 = new ChangeObjectThread("thread2");
        thread2.start();
        Thread.sleep(100);
        System.out.println(System.currentTimeMillis()+" -> ######### sleep 100 ##########");
        thread1.resume();
        thread2.resume();
    }
}
/** output:
 * 1504072559572 -> thread1======= begin ======
 * 1504072559573 -> thread1+++++++ enter lock ++++++
 * 1504072559672 -> ######### sleep 100 ##########
 * 1504072559672 -> thread2======= begin ======
 * 1504072559772 -> ######### sleep 100 ##########
 * 1504072559772 -> thread2+++++++ enter lock ++++++
 * 此时没有退出！！！
 */

public class SimpleJoinDemo {
    public volatile static int count =0;
    public static class IncreaseCountThread extends Thread{
        @Override
        public void run() {
            for (int i =0;i<1000000000;i++){
                count ++;
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Thread increaseCountThread = new IncreaseCountThread();
        increaseCountThread.start();
        increaseCountThread.join();
        System.out.println("field count is: "+String.valueOf(count));
    }
}
/*
 * field count is: 1000000000
 */

public final synchronized void join(long millis)
    throws InterruptedException {
        long base = System.currentTimeMillis();
        long now = 0;

        if (millis < 0) {
            throw new IllegalArgumentException("timeout value is negative");
        }

        if (millis == 0) {
            while (isAlive()) {
                wait(0);
            }
        } else {
            while (isAlive()) {
                long delay = millis - now;
                if (delay <= 0) {
                    break;
                }
                wait(delay);
                now = System.currentTimeMillis() - base;
            }
        }
    }

// https://github.com/openjdk/jdk/blob/master/src/hotspot/cpu/x86/x86.ad
instruct onspinwait() %{
  match(OnSpinWait);
  ins_cost(200);

  format %{
    $$template
    $$emit$$"pause\t! membar_onspinwait"
  %}
  ins_encode %{
    __ pause();
  %}
  ins_pipe(pipe_slow);
%}
// https://github.com/openjdk/jdk/blob/master/src/hotspot/cpu/riscv/riscv.ad
instruct spin_wait() %{
  predicate(UseZihintpause);
  match(OnSpinWait);
  ins_cost(CACHE_MISS_COST);

  format %{ "spin_wait" %}

  ins_encode %{
    __ pause();
  %}

  ins_pipe(pipe_serial);
%}

public class ThreadGroup2ThreadDemo {

    public static class  myThread implements Runnable{

        public void run() {
            try{
                while (!Thread.currentThread().isInterrupted())
                {
                    System.out.println(
                            "Group: " + Thread.currentThread().getThreadGroup().getName()+
                            " >> Thread: " + Thread.currentThread().getName());
                    Thread.sleep(300);
                }
            }
            catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        ThreadGroup threadGroup = new ThreadGroup("group1");
        Thread t1 = new Thread(threadGroup,new myThread());
        Thread t2 = new Thread(threadGroup,new myThread());
        // 线程启动(start)后才会加入线程组
        System.out.println("线程组中活动线程数量"+threadGroup.activeCount());
        t1.start();
        t2.start();
        Thread.sleep(100);
        System.out.println("线程组中活动线程数量"+threadGroup.activeCount());
        Thread.sleep(3000);
        threadGroup.interrupt();
    }
}

线程组中活动线程数量0
Group: group1 >> Thread: Thread-0
Group: group1 >> Thread: Thread-1
线程组中活动线程数量2
Group: group1 >> Thread: Thread-0
Group: group1 >> Thread: Thread-1
Group: group1 >> Thread: Thread-0
Group: group1 >> Thread: Thread-1
Group: group1 >> Thread: Thread-0
Group: group1 >> Thread: Thread-1
Group: group1 >> Thread: Thread-0
Group: group1 >> Thread: Thread-1
Group: group1 >> Thread: Thread-0
Group: group1 >> Thread: Thread-1
Group: group1 >> Thread: Thread-0
Group: group1 >> Thread: Thread-1
Group: group1 >> Thread: Thread-0
Group: group1 >> Thread: Thread-1
Group: group1 >> Thread: Thread-0
Group: group1 >> Thread: Thread-1
Group: group1 >> Thread: Thread-0
Group: group1 >> Thread: Thread-1
Group: group1 >> Thread: Thread-0
Group: group1 >> Thread: Thread-1
java.lang.InterruptedException: sleep interrupted
    at java.lang.Thread.sleep(Native Method)
    at cn.victor.test.ThreadGroup2ThreadDemo$myThread.run(ThreadGroup2ThreadDemo.java:14)
    at java.lang.Thread.run(Thread.java:748)
java.lang.InterruptedException: sleep interrupted
    at java.lang.Thread.sleep(Native Method)
    at cn.victor.test.ThreadGroup2ThreadDemo$myThread.run(ThreadGroup2ThreadDemo.java:14)
    at java.lang.Thread.run(Thread.java:748)

Process finished with exit code 0

public void list() {
    list(System.out, 0);
}
void More list(PrintStream out, int indent) {
    int ngroupsSnapshot;
    ThreadGroup[] groupsSnapshot;
    synchronized (this) {
        for (int j = 0 ; j < indent ; j++) {
            out.print(" ");
        }
        out.println(this);
        indent += 4;
        for (int i = 0 ; i < nthreads ; i++) {
            for (int j = 0 ; j < indent ; j++) {
                out.print(" ");
            }
            out.println(threads[i]);
        }
        ngroupsSnapshot = ngroups;
        if (groups != null) {
            groupsSnapshot = Arrays.copyOf(groups, ngroupsSnapshot);
        } else {
            groupsSnapshot = null;
        }
    }
    // 此处递归
    for (int i = 0 ; i < ngroupsSnapshot ; i++) {
        groupsSnapshot[i].list(out, indent);
    }
}

private int enumerate(Thread list[], int n, boolean recurse) {
    int ngroupsSnapshot = 0;
    ThreadGroup[] groupsSnapshot = null;
    synchronized (this) {
        if (destroyed) {
            return 0;
        }
        int nt = nthreads;
        if (nt > list.length - n) {
            nt = list.length - n;
        }
        for (int i = 0; i < nt; i++) {
            if (threads[i].isAlive()) {
                list[n++] = threads[i];
            }
        }
        if (recurse) {
            ngroupsSnapshot = ngroups;
            if (groups != null) {
                groupsSnapshot = Arrays.copyOf(groups, ngroupsSnapshot);
            } else {
                groupsSnapshot = null;
            }
        }
    }
    if (recurse) {
        for (int i = 0 ; i < ngroupsSnapshot ; i++) {
            n = groupsSnapshot[i].enumerate(list, n, true);
        }
    }
    return n;
}

public class ThreadGroup2GroupDemo {

    public static class  myThread implements Runnable{

        public void run() {
            try{
                while (!Thread.currentThread().isInterrupted())
                {
                    Thread.sleep(300);
                }
            }
            catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        /** 构建线程组结构
         *   head -> parentGroup -> p-A
         *                       -> p-B
         *                       -> childGroup -> c-a
         *                                     -> c-b
         *                                     -> childChildGroup -> cc-a
         */
        ThreadGroup parentGroup = new ThreadGroup("parentGroup");
        ThreadGroup childGroup = new ThreadGroup(parentGroup,"childGroup");
        ThreadGroup childChildGroup = new ThreadGroup(childGroup,"childChildGroup");

        Thread pThreadA = new Thread(parentGroup,new myThread(),"p-A");
        Thread pThreadB = new Thread(parentGroup,new myThread(),"p-B");
        Thread cThreada = new Thread(childGroup,new myThread(),"c-a");
        Thread cThreadb = new Thread(childGroup,new myThread(),"c-b");
        Thread ccThreada = new Thread(childChildGroup,new myThread(),"cc-a");


        pThreadA.start();
        pThreadB.start();
        cThreada.start();
        cThreadb.start();
        ccThreada.start();

        parentGroup.list();

        ThreadGroup[] list1 = new ThreadGroup[parentGroup.activeGroupCount()];
        System.out.println("递归获取线程组");
        parentGroup.enumerate(list1,true);
        for(int i =0;i<list1.length;i++){
            System.out.println(list1[i].getName());
        }
        ThreadGroup[] list2 = new ThreadGroup[parentGroup.activeGroupCount()];
        System.out.println("非递归获取线程组");
        parentGroup.enumerate(list2,false);
        for(int i =0;i<list2.length;i++){
            if(list2[i]!=null) {
                System.out.println(list2[i].getName());
            }
        }

        Thread[] list3 = new Thread[parentGroup.activeCount()];
        System.out.println("递归获取线程");
        parentGroup.enumerate(list3,true);
        for(int i =0;i<list3.length;i++){
            System.out.println(list3[i].getName());
        }
        Thread[] list4 = new Thread[parentGroup.activeCount()];
        System.out.println("非递归获取线程");
        parentGroup.enumerate(list4,false);
        for(int i =0;i<list4.length;i++){
            if(list4[i]!=null) {
                System.out.println(list4[i].getName());
            }
        }

        Thread.sleep(1000);
        // 中断所有线程
        parentGroup.interrupt();

    }
}

java.lang.ThreadGroup[name=parentGroup,maxpri=10]
    Thread[p-A,5,parentGroup]
    Thread[p-B,5,parentGroup]
    java.lang.ThreadGroup[name=childGroup,maxpri=10]
        Thread[c-a,5,childGroup]
        Thread[c-b,5,childGroup]
        java.lang.ThreadGroup[name=childChildGroup,maxpri=10]
            Thread[cc-a,5,childChildGroup]
递归获取线程组
childGroup
childChildGroup
非递归获取线程组
childGroup
递归获取线程
p-A
p-B
c-a
c-b
cc-a
非递归获取线程
p-A
p-B
java.lang.InterruptedException: sleep interrupted
    at java.lang.Thread.sleep(Native Method)
    at cn.victor.test.ThreadGroup2GroupDemo$myThread.run(ThreadGroup2GroupDemo.java:11)
    at java.lang.Thread.run(Thread.java:748)
java.lang.InterruptedException: sleep interrupted
    at java.lang.Thread.sleep(Native Method)
    at cn.victor.test.ThreadGroup2GroupDemo$myThread.run(ThreadGroup2GroupDemo.java:11)
    at java.lang.Thread.run(Thread.java:748)
java.lang.InterruptedException: sleep interrupted
    at java.lang.Thread.sleep(Native Method)
    at cn.victor.test.ThreadGroup2GroupDemo$myThread.run(ThreadGroup2GroupDemo.java:11)
    at java.lang.Thread.run(Thread.java:748)
java.lang.InterruptedException: sleep interrupted
    at java.lang.Thread.sleep(Native Method)
    at cn.victor.test.ThreadGroup2GroupDemo$myThread.run(ThreadGroup2GroupDemo.java:11)
    at java.lang.Thread.run(Thread.java:748)
java.lang.InterruptedException: sleep interrupted
    at java.lang.Thread.sleep(Native Method)
    at cn.victor.test.ThreadGroup2GroupDemo$myThread.run(ThreadGroup2GroupDemo.java:11)
    at java.lang.Thread.run(Thread.java:748)

Process finished with exit code 0

// openJdk 1.8

//　ThreadGroup 不指定线程组的初始化方法
public ThreadGroup(String name) {
    this(Thread.currentThread().getThreadGroup(), name);
}

// Thread init 初始化方法
private void init(ThreadGroup g, Runnable target, String name,
                       long stackSize, AccessControlContext acc) {
    Thread parent = currentThread();
    SecurityManager security = System.getSecurityManager();
    if (g == null) {
        /* Determine if it's an applet or not */
        /* If there is a security manager, ask the security manager what to do. */
        if (security != null) {
            g = security.getThreadGroup();
            /** 
             * // In Class SecurityManager
             * public ThreadGroup getThreadGroup() {
             * return Thread.currentThread().getThreadGroup();
             * }
             */
        }
 
        /* If the security doesn't have a strong opinion of the matter use the parent thread group. */
        if (g == null) {
            g = parent.getThreadGroup();
        }
    }
    ... ...
}