如何建立多线程

线程的状态

初始化—就绪—运行—终止

Sleep : 超时等待,过了一段时间就会进入就绪状态进行竞争cpu资源。

Wait: 等待状态，没有经过notify 或者 notifyAll 唤醒，就会一直进行等待。

Block: block io 或者 遇到加锁的代码时， 接受到数据或者获取到锁就会到运行状态，也有可能直接进入dead 状态。

public class NewThread implements Runnable {

    @Override
    public synchronized void run() {
        while (true) {
            System.out.println("线程运行了...");
            try {
//                Thread.sleep(100);
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        //建立线程并执行线程任务
        NewThread target = new NewThread();
        Thread thread = new Thread(target);
        //线程启动
        thread.start();

        while (true) {
            synchronized (target) {
                System.out.println("主线程");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                target.notify();
            }
        }
    }
}

建立线程的多种方式

继承Thread类

建立线程：

public class Demo1 extends Thread {

    public Demo1(String name) {
        super(name);
    }


    @Override
    public void run() {
        while (true) {
            System.out.println(getName() + "线程执行...");
        }
    }

    public static void main(String[] args) {
        Demo1 d1 = new Demo1("first-thread");
        Demo1 d2 = new Demo1("second-thread");

        //(守护线程) 即便线程没有执行完毕，只要主线程执行完了，线程就会退出
        d1.setDaemon(true);
        d2.setDaemon(true);
        d1.start();
        d2.start();
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }
}

线程的中断:

使用stop()方式没有释放锁和资源，只是让线程无限期的等待下去
推荐使用interrupt()

public class Demo1 extends Thread {

    public Demo1(String name) {
        super(name);
    }

    @Override
    public void run() {
        while (!interrupted()) {
            System.out.println(getName() + "线程执行...");
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    public static void main(String[] args) {
        Demo1 d1 = new Demo1("first-thread");
        Demo1 d2 = new Demo1("second-thread");

        d1.start();
        d2.start();
        d1.interrupt();

    }
}

实现Runnable接口

/**
 * 做为线程任务存在
 */
public class Demo2 implements Runnable {

    @Override
    public void run() {
        while (true) {
            System.out.println("thread running");
        }
    }
   
    public static void main(String[] args) {
        Thread thread = new Thread(new Demo2());
        thread.start();
    }
}

匿名内部类的方式

public class Demo3 {
    public static void main(String[] args) {
        //该线程仅建立一次
        new Thread() {
            @Override
            public void run() {
                while (true) {
                    System.out.println("thread start...");
                }
            }
        }.start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("thread start...");
            }
        }).start();

        //执行结果为sub
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("runnable");
            }
        }) {
            @Override
            public void run() {
                System.out.println("sub");
            }
        }.start();
    }
}

带返回值的线程

public class Demo4 implements Callable<Integer> {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //执行的任务
        Demo4 d = new Demo4();
        FutureTask<Integer> task = new FutureTask<Integer>(d);
        Thread t = new Thread(task);
        t.start();
        System.out.println("我先干点别的");
        //拿回返回结果
        Integer integer = task.get();
        System.out.println("线程执行的结果为:" + integer);
    }

    @Override
    public Integer call() throws Exception {
        System.out.println("正在进行紧张的计算");
        Thread.sleep(3000);

        return 1;
    }
}

定时器

public class Demo5 {

    public static void main(String[] args) {
        Timer timer = new Timer();
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                //实现定时任务
                System.out.println("timertask is run");
            }
        }, 0, 1000);
    }
}

线程池的实现

newFixedThreadPool:

public class Demo6 {

    public static void main(String[] args) {
        ExecutorService threadPool = Executors.newFixedThreadPool(10);

        for (int i = 0; i < 100; i++) {
            threadPool.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName());
                }
            });
        }
        threadPool.shutdown();
    }
}

newCachedThreadPool：

public class Demo6 {
    public static void main(String[] args) {

        //比较智能的线程池，不够用就建立，够用就回收
        ExecutorService threadPool = Executors.newCachedThreadPool();

        for (int i = 0; i < 100; i++) {
            threadPool.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName());
                }
            });
        }

        threadPool.shutdown();
    }
}

Lambda表达式实现

public class Demo7 {

    public int add(List<Integer> values) {
//        values.stream().forEach(System.out::println);
        return values.parallelStream().mapToInt(a -> a).sum();
    }

    public static void main(String[] args) {
        List<Integer> values = Arrays.asList(10, 20, 30, 40);
        int result = new Demo7().add(values);
        System.out.println(result);
    }
}

Spring 实现多线程

Main方法：

public class Application {

    public static void main(String[] args) {
        AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(Config.class);
        DemoService bean = ac.getBean(DemoService.class);
        bean.a();
        bean.b();
    }

}

相关配置

@Configuration
@ComponentScan("com.autohome.data.realtime.demo")
@EnableAsync
public class Config {

}

异步代码:
 

@Service
public class DemoService {

    @Async
    public void a() {
        while (true) {
            System.out.println("a");
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }
    @Async
    public void b() {
        while (true) {
            System.out.println("b");
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}