Java语言基础线程

1.创建和启动线程

　　线程类必须实现Runnable接口或者扩展Thread类，并且实现run方法，run方法没有参数没有返回值不允许抛出异常。调用start实例方法启动一个线程。调用该方法后，线程准备启动，只有获得CPU时，start将自动调用run，线程才真正启动。

public class DefineThread {
    /**
     * 通过继承java.lang.Thread类定义线程
     */
    class ThreadA extends Thread{
        /**
         * 当线程被运行时调用此方法
         */
        public void run(){
            System.out.println("ThreadA begin,");
            System.out.println("ThreadA end.");
        }
    }
    
    /**
     * 通过实现java.lang.Runnable接口定义线程
     */
    class ThreadB implements Runnable{
        public void run(){
            System.out.println("ThreadB begin,");
            System.out.println("ThreadB end.");
        }
    }
    
    public static void main(String[] args) {
        DefineThread test = new DefineThread();
        //线程的运行具有不确定性，先启动的线程不一定先运行，取决于虚拟机。
        
        Thread threadA = test.new ThreadA();
        Runnable tb = test.new ThreadB();
        Thread threadB = new Thread(tb);
        threadA.start();
        threadB.start();
        
    }
}

2.停止线程

　　为线程设置一个布尔属性，表示线程是否运行，在run方法中适当地检测标志位，为true时继续运行，需要停止线程时设置标志位为false。

class MyThread extends Thread {
    private boolean running = false;
    public void start() {
        running = true;
        super.start();
    }
    
    public void run() {
        try {
            while(running) {
                System.out.println("mythread is running");
                Thread.sleep(200);
            }
        }catch(InterruptedException e){
        }
        System.out.println("mythread stop.");
    }
    
    public void stopMyThread() {
        running = false;
    }
}

public class ThreadStop {
    public static void main(String[] args) {
        MyThread mt = new MyThread();
        mt.start();
        try{
            Thread.sleep(2000);
        }catch(InterruptedException e){
        }
        mt.stopMyThread();
    }
}

3.线程互斥

　　在类的方法声明中使用synchronized可以保证在同一时刻只有一个线程能够进入该方法。

public class ThreadSynchronized {
    
    public synchronized void synchronizedMethod() {
        System.out.println("Thread in method is：" + Thread.currentThread().getName());
        System.out.println("other thread can't enter the method now.");
        
        try{
            Thread.sleep(5000);
        }catch(InterruptedException e){
        }
        
        System.out.println(Thread.currentThread().getName() + " have done its work, leaving method.");
    }
    
    public static void main(String[] args){
        final ThreadSynchronized obj = new ThreadSynchronized();
        
        Thread thread1 = new Thread() {
            public void run() {
                obj.synchronizedMethod();
            }
        };
        
        Thread thread2 = new Thread() {
            public void run() {
                obj.synchronizedMethod();
            }
        };
        
        thread1.start();
        try{
            Thread.sleep(100);
        }catch(InterruptedException e){
        }
        thread2.start();
    }
}

4.线程协作

　　在synchronized代码块中使用wait方法，能够使当前线程进入等待状态，并释放当前线程拥有的对象锁。在synchronized代码块中使用notify或者notifyAll方法，当前线程释放对象锁，唤醒其它等待该对象锁的线程。当有多个线程都在等待该对象锁时，由虚拟机决定被唤醒的线程。

class CubbyHole {
    private Object slot;
    
    public CubbyHole() {
        slot = null;
    }
    
    public synchronized void putIn(Object obj) throws InterruptedException{
        System.out.println(Thread.currentThread().getName() + "want to putin a object");
        while(slot != null){
            System.out.println("cubbyhole is full, need to wait.");
            wait();
            System.out.println(Thread.currentThread().getName() + "wake up!");
        }
        
        slot = obj;
        System.out.println("fill a object, notify others.");
        notifyAll();
    }
    
    public synchronized Object takeOut()throws InterruptedException {
        System.out.println(Thread.currentThread().getName() + "want to takeout an object.");
        while(slot == null){
            System.out.println("the cubbyhole is empty, need to wait");
            wait();
            System.out.println(Thread.currentThread().getName() + "wake up!");
        }
        
        Object obj = slot;
        slot = null;
        System.out.println("clear the cubbyhole, notify others.");
        notifyAll();
        return obj;
    }
}

public class CubbyHoleMain {
    public static void main(String[] args){
        final CubbyHole ch = new CubbyHole();
        
        Runnable runA = new Runnable() {
            public void run() {
                try{
                    String str;
                    Thread.sleep(500);
                    
                    for(int i = 1; i < 11; i++){
                    str = "multithread" + i;
                    ch.putIn(str);
                    System.out.println(Thread.currentThread().getName() + " putin ' " + str + " ' ");
                }
                    /*str = "programming";
                    ch.putIn(str);
                    System.out.println(Thread.currentThread().getName() + " putin ' " + str + " ' ");
                    
                    str = "with java";
                    ch.putIn(str);
                    System.out.println(Thread.currentThread().getName() + " putin ' " + str + " ' ");*/
                }catch(InterruptedException e){
                    e.printStackTrace();
                }
            }
        };
        
        Runnable runB = new Runnable() {
            public void run() {
                try{
                    Object obj;
                    
                    obj = ch.takeOut();
                    System.out.println(Thread.currentThread().getName() + "takeout ' " + obj + " ' ");
                    
                    Thread.sleep(500);
                    
                    for(int i = 0; i < 9; i++){
                    obj = ch.takeOut();
                    System.out.println(Thread.currentThread().getName() + "takeout ' " + obj + " ' ");
                }
                /*    obj = ch.takeOut();
                    System.out.println(Thread.currentThread().getName() + "takeout ' " + obj + " ' ");*/
                }catch(InterruptedException e){
                    e.printStackTrace();
                }
            }
        };
        
        Thread threadA = new Thread(runA, "threadA");
        Thread threadB = new Thread(runB, "threadB");
        threadA.start();
        threadB.start();
    }
}

5.线程优先级

　　Java线程优先级分为10个级别，数字越大级别越高，默认为5级。Thread.MAX_PRIORITY和Thread.MIN_PRIORTY和Thread.NORM_PRIORTY是Thread的3个static final成员，分别是10，1，5。

public class Priority {
    
    static class MyThread extends Thread{
        private int ID = 0;
        public MyThread(int id){
            this.ID = id;
        }
        public void run(){
            System.out.println("MyThread-" + this.ID + 
                    " begin! Priority: " + this.getPriority());

            System.out.println("MyThread-" + this.ID + " end!");
        }
    }

    public static void main(String[] args) {
        //建立3个优先级不同的线程
        MyThread[] myThreads = new MyThread[3];
        for (int i=0; i<3; i++){
            myThreads[i] = new MyThread(i+1);
            //三个线程的优先级分别是1，4，7
            myThreads[i].setPriority(i*3+1);
        }
        //按优先级从低到高启动线程
        for (int i=0; i<3; i++){
            myThreads[i].start();
        }
        //先启动的线程不一定先运行，虚拟机会考虑线程的优先级，同等情况下，优先级高的线程先运行
    }
}