线程

1.线程的生命周期

 2.新建线程

实现Runnable接口中的run()方法

public class User implements Runnable {

    @Override
    public void run() {
        System.out.println("run");
    }

    public static void main(String[] args) {
        Thread t = new Thread(new User());
        t.start();
    }
}

3.中断线程

• 为线程设置标志位，在run()方法中设定结束条件，在其他线程修改了标志位以后，退出线程。

不要使用stop()方法结束线程，使用stop会使线程释放它持有的锁，导致数据的不一致性。如：用线程读写user，这个user本来id=1,name=1，写线程使用stop方法结束，导致刚写完user的id=1线程的锁就被释放了，此时有一个线程读取了这个user，有可能会读出user的id=1,name=0这种不一致结果。

package com.company;
public class User implements Runnable {
    public volatile boolean exit = false;
    @Override
    public void run() {
        while (true){
            if (exit) {
                System.out.println("exit");
                break;
            }
            System.out.println("running");
        }
    }

    public static void main(String[] args) throws InterruptedException {
        User u = new User();
        Thread t = new Thread(u);
        t.start();
        Thread.sleep(10);
        u.exit = true;
    }
}

• 使用interrupt()方法中断线程，不是立即中断，而是告诉目标线程，有人希望你退出了。

interrupt()相当于设置了中断标志，需要在运行的线程当中捕获这个标志并进行处理。

下面的程序每隔0.5秒输出一个数字，5秒后设置中断，运行的线程处理中断的逻辑是退出线程，因此输出到9程序退出。

注意sleep()方法在休眠过程中，被中断会抛出中断异常，抛出中断异常后会清除中断标志，如果不在sleep()的中断块中处理中断逻辑，需要重新设置中断标志。

package com.company;

public class User implements Runnable {
    private volatile int i = 0;
    @Override
    public void run() {
        while(true){
            if(Thread.currentThread().isInterrupted()){
                System.out.println("exit");
                break;
            }
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                //e.printStackTrace();
                Thread.currentThread().interrupt();
            }
            System.out.println(i++);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(new User());
        t.start();
        Thread.sleep(5000);
        t.interrupt();
    }
}

 4.wait()和notify()

wait()和notify()方法是Object的方法，这2个方法用来完成线程之间的协作。

wait()和notify()方法需要持有对象的锁，因此必须放在synchronized块中。

某个线程t1内调用一个对象object.wait()方法，会将t1线程加入到object的等待队列中，等待被notify()，注意notify()是随机唤醒，不是顺序唤醒。

package com.company;

import java.text.SimpleDateFormat;

public class Main {
    private static Main obj = new Main();
    public static class WaitThread extends Thread{

        @Override
        public void run() {
            synchronized (obj){
                System.out.println("等线程启动！");
                try {
                    obj.wait();
                } catch (InterruptedException e) {
                }
                SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                System.out.println(df.format(System.currentTimeMillis()));
                System.out.println("等线程结束!");
            }
        }
    }
    public static class NotifyThread extends Thread{
        @Override
        public void run() {
            synchronized (obj){
                SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                System.out.println(df.format(System.currentTimeMillis()));
                System.out.println("唤醒线程启动！");
                obj.notify();
                System.out.println("唤醒!");
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("释放锁！");
            }
        }
    }
    public static void main(String[] args) {
        Thread t1 = new WaitThread();
        Thread t2 = new NotifyThread();
        t1.start();
        t2.start();

    }
}

 5.join

join使当前线程等待某个线程执行完了以后在执行下面的代码。

package com.company;

public class User implements Runnable {
    public static volatile int i = 0;
    @Override
    public void run() {
        for(;i<10000;i++);
    }

    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(new User());
        t.start();
        t.join();
        System.out.println(i);
    }
}

注释了join的话，有可能会输出0，表示t线程还没有执行完，主线程就输出了。

6.线程组

把线程加到不同的组里，方便管理。

package com.company;

public class User implements Runnable {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getThreadGroup().getName() + Thread.currentThread().getName());
    }

    public static void main(String[] args) throws InterruptedException {
        ThreadGroup gp = new ThreadGroup("printgp");
        Thread t1 = new Thread(gp,new User(),"t1");
        Thread t2 = new Thread(gp,new User(),"t2");
        t1.start();
        t2.start();
    }
}

7.守护线程

守护线程是为用户线程默默服务的线程，如果系统里只有守护线程，那么程序会退出。

守护线程不停的打印i的值，但是用户线程main在3秒以后退出，所以main线程结束后，守护线程也结束了。

package com.company;

public class User implements Runnable {
    @Override
    public void run() {
       int i = 0;
       while(true){
           System.out.println(i++);
           try {
               Thread.sleep(1000);
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
       }
    }

    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(new User());
        t.setDaemon(true);
        t.start();
        Thread.sleep(3000);
    }
}

8.线程优先级

线程优先级从1-10，在抢占资源时，高优先级的线程会比低优先级的线程更容易抢占到资源。

经过几秒钟的实验，优先级高的能比优先级低的抢占更多次资源。

package com.company;

public class User implements Runnable {
    public static volatile int lowNum = 0;
    public static volatile int maxNum = 0;
    public static volatile int runNum = 0;
    @Override
    public void run() {
        while(true){
            synchronized (User.class){
                runNum++;
                if(Thread.currentThread().getName() == "low")
                    lowNum++;
                else maxNum++;
            }
            System.out.println("总比赛次数"+runNum+",low获胜次数"+lowNum+",max获胜次数"+maxNum);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(new User(),"low");
        Thread t2 = new Thread(new User(),"max");
        t1.setPriority(Thread.MIN_PRIORITY);
        t2.setPriority(Thread.MAX_PRIORITY);
        t1.start();
        t2.start();
    }
}

 9.synchronized

synchronized关键字把某段代码设定为blocked状态，blocked状态的代码块，一次只能有一个线程进入，从而使某些公共资源对所有的线程来讲都是同步的。

未进行同步的代码，最终输出的i值都到不了100000000.

package com.company;

public class User implements Runnable {
    private static User user = new User();
    private static int i = 0;
    @Override
    public void run() {
        for (int j = 0; j < 100000000; j++) {
            i++;
        }
        System.out.println(i);
    }

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(new User());
        Thread t2 = new Thread(new User());
        t1.start();
        t2.start();
    }
}

三种方法同步

• 同步实例对象

package com.company;

public class User implements Runnable {
    static User user = new User();
    static int i = 0;
    @Override
    public void run() {
        //对实例对象user同步
        synchronized (user){
            for (int j = 0; j < 10000000; j++) {
                i++;
            }
            System.out.println(i);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        //保证2个线程使用同一个实例对象创建
        Thread t1 = new Thread(user);
        Thread t2 = new Thread(user);
        t1.start();
        t2.start();
    }
}

• 同步实例方法

package com.company;

public class User implements Runnable {
    static User user = new User();
    static int i = 0;
    //使用synchronized同步实例方法
    public synchronized void increase(){
        for (int j = 0; j < 10000000; j++) {
            i++;
        }
        System.out.println(i);
    }
    @Override
    public void run() {
        increase();
    }

    public static void main(String[] args) throws InterruptedException {
        //保证2个线程使用同一个实例对象创建
        Thread t1 = new Thread(user);
        Thread t2 = new Thread(user);
        t1.start();
        t2.start();
    }
}

• 同步类

package com.company;

public class User implements Runnable {
    static int i = 0;
    @Override
    public void run() {
        //同步类
        synchronized (User.class) {
            for (int j = 0; j < 10000000; j++) {
                i++;
            }
            System.out.println(i);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        //保证2个线程使用同一个实例对象创建
        Thread t1 = new Thread(new User());
        Thread t2 = new Thread(new User());
        t1.start();
        t2.start();
    }
}