终止线程

Thread类有一个方法 stop. 已经被禁用  当你使用stop()时，程序会强制中断进程并立即退出，那么这时候就会立即释放锁，这时候就会出现读写混乱 如下程序

package com.longfor.dragonshard.service.cost.standard.impl;

public class StopThreadUnsafe {
    public static User user = new User();
    public static class User{

        private int id;

        private String name;

        public User(){
            id=0;
            name="0";
        }

        public int getId() {
            return id;
        }

        public void setId(int id) {
            this.id = id;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        @Override
        public String toString() {
            return "User{" +
                    "id=" + id +
                    ", name='" + name + '\'' +
                    '}';
        }
    }

    public static class ChangeObjectThread extends Thread{

        private volatile boolean stopme = false;
        public void stopMe(){
            stopme = true;
        }

        @Override
        public void run() {

            while (true){
                if (stopme==true){
                    break;
                }
                synchronized (user){
                    int u = (int)(System.currentTimeMillis()/1000);
                    user.setId(u);
                    try {
                        Thread.sleep(100);
                    }catch (Exception e){
                        e.printStackTrace();
                    }
                    user.setName(String.valueOf(u));
                }
                Thread.yield();
            }
        }
    }


    public static class ReadObjectThread extends Thread{
        @Override
        public void run() {
            while (true){
                synchronized (user){
                    if (user.getId() != Integer.parseInt(user.getName())){
                        System.out.println(user.toString());
                    }
                }
                Thread.yield();
            }
        }
    }

    public static void main(String[] args) throws Exception{
        new ReadObjectThread().start();
        while (true){
            ChangeObjectThread thread = new ChangeObjectThread();
            thread.start();
            Thread.sleep(100);
            thread.stop();
        }
    }
}

所以我们自己设置中断条件 而不是用stop Java自己也有设置中断条件

interrupt()   设置中断状态

isInterrupt() 判断是否中断

interrupted() 判断是否中断 并清除中断状态

设置中断状态实际上是向程序发送一个通知  有人希望你结束进程 那么操作完全由程序自己控制  如果程序立即退出 那么就又相当于stop 所以我们要增加中断处理代码  

如果我们不增加中断代码 只是增加中断状态 那么程序还是由程序自己控制 而不是我们

package com.longfor.dragonshard.service.cost.standard.impl;

public class Interrupt {
    public static void main(String[] args) throws InterruptedException{
        MyThread thread = new MyThread();
        thread.start();
        Thread.sleep(1000);
        thread.interrupt();
    }
    public static class MyThread extends Thread{
        @Override
        public void run() {
            while (true){
                if (Thread.currentThread().isInterrupted()){
                    System.out.println("this thread is interrupted..");
                    break;
                }
                Thread.yield();
            }
        }
    }
}

当我们使用sleep时 程序会抛出中断 那么我们捕获它 一旦捕获 那么中断状态就会清除  所以我们在加上中断状态

package com.longfor.dragonshard.service.cost.standard.impl;

public class SleepInterrupt {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start();
        myThread.interrupt();
    }
    public static class MyThread extends Thread{
        @Override
        public void run() {
            while (true){
                if (Thread.currentThread().isInterrupted()){
                    System.out.println("this thread is interrupted...");
                    break;
                }
                try {
                    Thread.sleep(2000);
                }catch (InterruptedException e){
                    System.out.println(e.getMessage());
                    Thread.interrupted();
                }
                Thread.yield();
            }
        }
    }
}

 Join 意为加入线程  运行结果为10000 main线程中加入join 等待join执行完毕一起走   

 Join本质为调用线程实例对象上的wait方法  当线程结束时 退出队列 notifyall所有线程

while (isAlive()) {
    wait(0);
}

package com.longfor.dragonshard.service.cost.standard.impl;

public class JoinMain {
    public static int i = 0;
    public static void main(String[] args) throws InterruptedException{
        Joinmain joinmain = new Joinmain();
        joinmain.start();
        joinmain.join();
        System.out.println(i);
    }
    public static class Joinmain extends Thread{

        @Override
        public void run() {
            for(i=0;i<10000;i++);
        }
    }
}

volatile意为易变的 不可控的 用volatile修饰就会使cpu更加重视这个变量 如果有改变 那么其他线程需要可以看见  
但是对于一些原子性的操作 这个volatile也不会发生作用

package com.longfor.dragonshard.service.cost.standard.impl;

public class PlusTask {
    private static volatile int i = 0;
    public static void main(String[] args) throws InterruptedException{
        Thread[] threadarray = new Thread[10];
        for(int i=0;i<10;i++){
            threadarray[i]=new Thread(new plustask());
            threadarray[i].start();
        }
        for(int i=0;i<10;i++){
            threadarray[i].join();
        }
        System.out.println(i);
    }
    public static class plustask implements Runnable{
        @Override
        public void run() {
            for(int k=0;k<10000;k++){
                i++;
            }
        }
    }
}

 线程组

package com.longfor.dragonshard.service.cost.standard.impl;

public class ThreadGroupName implements Runnable{

    /*
     * Initializes a Thread with the current AccessControlContext.
     * @see #init(ThreadGroup,Runnable,String,long,AccessControlContext,boolean)
    private void init(ThreadGroup g, Runnable target, String name,
                      long stackSize) {
        init(g, target, name, stackSize, null, true);
    }
    */
    public static void main(String[] args) {
        ThreadGroup threadGroup = new ThreadGroup("PrintGroup");
        Thread t1 = new Thread(threadGroup,new ThreadGroupName(),"T1");
        Thread t2 = new Thread(threadGroup,new ThreadGroupName(),"T2");
        t1.start();
        t2.start();
        System.out.println(threadGroup.activeCount());
        threadGroup.list();
    }
    @Override
    public void run() {
        String name = Thread.currentThread().getThreadGroup().getName()+"--"+Thread.currentThread().getName();
        while(true){
            try {
                System.out.println(name);
                Thread.sleep(3000);
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }

    }
}