线程应用：（五）传统线程使用实例

一、创建线程的两种方式

（1）子类继承Thread，并重写run方法

public static void main(String[] args) {
    SubThread s1 = new SubThread();
    SubThread s2 = new SubThread();
    s1.start();
    s2.start();
}

class SubThread extends Thread{
    @Override
    public void run() {
        while(true){
            System.out.println(Thread.currentThread());    //每隔0.5s打印当前线程对象的名称
        }
    }
}

（2）实现Runnable接口，传到thread里

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

class MyRunnable implements Runnable{
    @Override
    public void run() {
        while(true){
            System.out.println(Thread.currentThread());    //打印当前线程对象的名称      
        }    
    }
}

　　一般用第二种方式，实现接口不影响继承其他父类。

　　如果Thread类既重写了run方法，又传了一个Runnable接口，会调用Thread子类重写的run方法，因为找Runnable对象是在Thread类的run方法执行的，如果被子类覆盖就不会执行。

　　采用多线程不一定会让程序运行效率更高，取决于CPU，线程间的切换也会增加消耗。

二、线程互斥实现案例

　　使用synchronized实现互斥。

//互斥代码案例
public class ThreadTest {
    public static void main(String[] args) {
        new ThreadTest().init();
    }

    //起了两个线程，一个一直输出"AAAAAA"，一个一直输出"BBBBBB"，但调用方法的对象是同一个
    public void init(){
        final Outputer outputer = new Outputer();
        new Thread(new Runnable() {
            @Override
            public void run() {
                while(true){
                    outputer.output("AAAAAA");
                }
            }
        }).start();
        
        new Thread(new Runnable() {
            @Override
            public void run() {
                while(true){
                    outputer.output2("BBBBBB");
                }
            }
        }).start();
    }
}

class Outputer {
    public void output(String name){
        //synchronized (Outputer.class) {
        synchronized (this) {
            int len = name.length();
            for(int i=0;i<len;i++){
                System.out.print(name.charAt(i));
            }
            System.out.println("");  //换行
        }
    }
    public synchronized void output2(String name){
        int len = name.length();
        for(int i=0;i<len;i++){
            System.out.print(name.charAt(i));
        }
        System.out.println("");
    }
    public static synchronized void output3(String name){
        int len = name.length();
        for(int i=0;i<len;i++){
            System.out.print(name.charAt(i));
        }
        System.out.println("");
    }
}

线程不安全下的输出结果：
BBBBBB
BBAAAAAA
AAAAAA

案例场景：有两个线程，一个一直输出"AAAAAA"，一个一直输出"BBBBBB"，输出完后会换行，如果没有做任何互斥操作，是线程不安全的，就会出现如图所示在还未输出完B时就会输出A的情况。

关键点：

1）如果多个线程要实现互斥，用的锁对象必须要是同一个。

2）调用output()、output2()方法的是同一个对象，且output()和output2()都是用当前对象作为锁对象，所以即使线程1调用output()，线程2调用output2()也能保证线程安全。

3）output3()是静态方法，用是类作为锁对象，如果要和output()方法互斥，output()的锁对象要由this改成Outputer.class。

三、线程同步实现案例

场景：子线程先单独循环10次，接着主线程再单独循环100次，如此反复50次。使用synchronized、wait、notify关键字。

思路：

1）先保证每个线程一轮的原子性（把要实现互斥的相关联的方法，或是共享同样变量的方法放在同一个类里，线程的同步问题在这个类里考虑）

2）再让主线程和子线程间交替进行，通过wait，notify等待唤醒，synchronized用的锁对象和wait，notify调用的对象一样

public class ThreadTest {
    public static void main(String[] args) throws InterruptedException {
        final Business business = new Business();
        
        new Thread(new Runnable() {
            @Override
            public void run() {
                for(int i=1;i<=50;i++){        //循环50轮
                    try {
                        business.forSub(i);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }).start();
        
        for(int i=1;i<=50;i++){        //循环50轮
            business.forMain(i);
        }
    }
}

//加synchronized保证每轮原子性
//要用到共同数据（包括同步锁）的若干方法应该归于一个类上
class Business {
    private boolean subGo = true;    //用来让主子线程交替进行的标识
    
    //子线程每轮循环10次
    public synchronized void forSub(int i) throws InterruptedException{
        while(!subGo){        //用while防止伪唤醒
            this.wait();    //不该子线程执行的时候暂停
        }
        
        for(int j=1;j<=10;j++){
            System.out.println("subThread of, 第"+i+"轮, 序列为:"+j);
        }
        subGo = false;    //子线程执行完释放标识
        this.notify();    //唤醒另一个线程
    }
    
    //主线程每轮循环100次
    public synchronized void forMain(int i) throws InterruptedException{
        while(subGo){
            this.wait();    //该子线程执行的时候主线程暂停
        }
        for(int j=1;j<=100;j++){
            System.out.println("mainThread of, 第"+i+"轮, 序列为:"+j);
        }
        subGo = true;    //表示主线程执行完该子线程执行了
        this.notify();
    }
}

四、ThreadLocal（一个线程内各模块间共享同一数据，各线程间的数据又是独立的）

　　线程范围内的共享变量，每个线程有自己独立的数据。例如每个线程要有自己独立的连接。ThreadLocal本质上是一个map。

public class ThreadTest3 {
    private static ThreadLocal<Integer> x = new ThreadLocal<Integer>();
    
    public static void main(String[] args){
        for(int i=0;i<2;i++){
            new Thread(new Runnable() {
                @Override
                public void run() {
                    int data = new Random().nextInt();
                    System.out.println(Thread.currentThread().getName()+"has put data:" + data);
                    x.set(data);    //往当前线程ThreadLocal存数据
                    new A().get();
                    new B().get();
                }
            }).start();
        }
    }
    
    //A模块调用该线程变量
    static class A {
        public void get(){
            int data = x.get();
            System.out.println("A from "+Thread.currentThread().getName()+"has put data:" + data);
        }
    }
    //B模块
    static class B {
        public void get(){
            int data = x.get();
            System.out.println("B from "+Thread.currentThread().getName()+"has put data:" + data);
        }
    }
}

运行结果：
Thread-0has put data:-247142886
Thread-1has put data:-2028241651
A from Thread-1has put data:-2028241651
A from Thread-0has put data:-247142886
B from Thread-1has put data:-2028241651
B from Thread-0has put data:-247142886

　　只要定义一个ThreadLocal变量，往这个变量里放的数据就是和线程相关的。一个ThreadLocal只能放一个变量，如果要存多个变量可以利用实体类。结合单例模式，把ThreadLocal定义在实体类。

public class ThreadTest4 {
    public static void main(String[] args){
        for(int i=0;i<2;i++){
            new Thread(new Runnable() {
                @Override
                public void run() {
                    int data = new Random().nextInt();
                    System.out.println(Thread.currentThread().getName()+"has put data:" + data);
                    Entity.getInstance().setData(data);        //拿到本线程在这个类里对应的实例，再赋值
                    new A().get();
                    new B().get();
                }
            }).start();
        }
    }
}

class A {
    public void get(){
        Entity mydata = Entity.getInstance();
        System.out.println("A from "+Thread.currentThread().getName()+"has put data:" + mydata.getData());
    }
}

class B {
    public void get(){
        Entity mydata = Entity.getInstance();
        System.out.println("B from "+Thread.currentThread().getName()+"has put data:" + mydata.getData());
    }
}

//多变量实体类
class Entity{
    private Entity(){}
    private static ThreadLocal<Entity> map = new ThreadLocal<Entity>();    //在这个类中定义一个ThreadLocal，存每个线程对应的实例
    public static /*synchronized*/ Entity getInstance(){    //一般单例加synchronized会更严谨一点，这里取的就是本线程的实体类，所以可不加
        Entity instance = map.get();
        if(instance == null){        //如果这个线程还没有对应的实例，才往ThreadLocal存
            instance = new Entity();
            map.set(instance);        
        }
        return instance;
    }
    int data;
    public int getData() {
        return data;
    }
    public void setData(int data) {
        this.data = data;
    }
}

运行结果：
Thread-0has put data:2114567887
Thread-1has put data:-746942766
A from Thread-1has put data:-746942766
A from Thread-0has put data:2114567887
B from Thread-0has put data:2114567887
B from Thread-1has put data:-746942766

　　每个线程结束后应该要清空对应的记录，垃圾回收会自动回收结束线程对应的记录，也可以调ThreadLocal的remove();方法移除。

（*）传统定时器技术，Timer类、开源工具Quartz

import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;

public class Test {  
    public static void main(String[] args) {
       Timer timer = new Timer();  
       timer.schedule(new TimerTaskTest(), 1000);        //1s后运行
       timer.schedule(new TimerTaskTest(), 1000, 2000); //1s后运行，然后再每隔2s运行一次
       timer.schedule(new TimerTaskTest(), new Date()); //根据具体日期定时
    }
}

//要执行的任务
class TimerTaskTest extends TimerTask{
    @Override
    public void run() {
        //定时要执行的代码逻辑
        System.out.println(new Date()+"执行任务");
    }  
}