多线程知识回顾、sping @Async的使用

一、创建多线程的三种方式

1.1继承Thread

继承Thread，重新run方法，调用start（）方法

public class Thread1 extends Thread {
    @Override
    public void run() {
        //run方法线程体
        System.out.println("000000");
    }
    public static void main(String[] args) {
        //创建一个线程对象
        Thread1 testThread = new Thread1();
        //调用start（）开启线程
        testThread.start();
    }
}

1.2实现runnable

实现runnable，实现run()方法，用Threa的start()方法静态代理执行

public class CreateRunnable implements Runnable {

    @Override
    public void run() {
        //run方法线程体
        System.out.println("000000");
    }

    public static void main(String[] args) {
        //创建runnable接口的实现类对象
        CreateRunnable testThread = new CreateRunnable();
        //创建线程对象,通过线程对象来开启我们的线程,代理
        Thread thread = new Thread(testThread);
        //调用start（）开启线程
        thread.start();
    }
}

1.3实现callable（有返回值）

线程池执行，获取返回值

public class MyCallable implements Callable<String> {
 
    /**
     * 实现call方法，接口中抛出异常。因为子类不可以比父类干更多的坏事，所以子类可以不抛出异常
     */
    @Override
    public String call() {
        System.out.println(Thread.currentThread().getName() + "   执行callable的call方法");
        return "result";
    }
 
    public static void main(String[] args) {
        test2();
    }
/**
     * 多个线程
     */
    public static void test2() {
        // 1.创建固定大小的线程池(5个)
        int threadNum = 5;
        ExecutorService es = Executors.newFixedThreadPool(threadNum);
        // 2.提交线程任务，用Future接口接受返回的实现类
        List<Future<String>> futures = new ArrayList<Future<String>>(threadNum);
        for (int i = 0; i < threadNum; i++) {
            Future<String> future = es.submit(new MyCallable());
            futures.add(future);
        }
        // 3.关闭线程池
        es.shutdown();
        // 4.调用future.get()获取callable执行完成的返回结果
        for (Future<String> future : futures) {
            try {
                String result = future.get();
                System.out.println(Thread.currentThread().getName() + "\t" + result);
            } catch (InterruptedException | ExecutionException e) {
                e.printStackTrace();
            }
        }
    }
}

二、线程同步

2.1synchronized 关键字

1、synchronized 同步方法,锁的是this
2、同步方法块synchronized (obj){}，需要放入同步的对象，当作锁

//安全买票
public class Demo27_SafeBuyTicket {
    public static void main(String[] args) {
        BuyTicket1 buyTicket = new BuyTicket1();
        new Thread(buyTicket, "张三").start();
        new Thread(buyTicket, "李四").start();
        new Thread(buyTicket, "王五").start();
    }
}

class BuyTicket1 implements Runnable {
    //票
    private int ticketNums = 10;
    boolean flag = true;

    @Override
    public void run() {
        //买票
        while (flag) {
            try {
                buy();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    //synchronized 同步方法,锁的是this
    private synchronized void buy() {
        //判断是否有票
        if (ticketNums <= 0) {
            flag = false;
            return;
        }
        //延迟
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        //买票
        System.out.println(Thread.currentThread().getName() + "拿到" + ticketNums--);
    }
}

2.2lock锁

显式的加锁和解锁,常用的锁：ReentrantLock 重入锁

//测试Lock锁
public class Demo32_ThreadLock {
    public static void main(String[] args) {
        TestLock testLock = new TestLock();
        new Thread(testLock).start();
        new Thread(testLock).start();
        new Thread(testLock).start();
    }
}

class TestLock implements Runnable {
    int tickerNums = 10;
    //定义Lock锁
    private final ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        while (true) {
            //加锁
            try {
                lock.lock();
                if (tickerNums <= 0) {
                    break;
                }
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(tickerNums--);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                //解锁
                lock.unlock();
            }
        }
    }
}

三、扩展：使用 Spring的@Async解决IO操作

注意事项:如下方式会使@Async失效
    异步方法使用static修饰
    异步类没有使用@Component注解（或其他注解）导致spring无法扫描到异步类
    异步方法不能与被调用的异步方法在同一个类中
    类中需要使用@Autowired或@Resource等注解自动注入，不能自己手动new对象
    如果使用SpringBoot框架必须在启动类中增加@EnableAsync注解

3.1配置类

    @Configuration  
    @EnableAsync  //开启异步功能
    public class ThreadPoolTaskConfig {  
    /**   
     *   默认情况下，在创建了线程池后，线程池中的线程数为0，当有任务来之后，就会创建一个线程去执行任务，  
     *    当线程池中的线程数目达到corePoolSize后，就会把到达的任务放到缓存队列当中；  
     *  当队列满了，就继续创建线程，当线程数量大于等于maxPoolSize后，开始使用拒绝策略拒绝   
     */  
        /** 核心线程数（默认线程数） */  
        private static final int corePoolSize = 20;  
        /** 最大线程数 */  
        private static final int maxPoolSize = 100;  
        /** 允许线程空闲时间（单位：默认为秒） */  
        private static final int keepAliveTime = 10;  
        /** 缓冲队列大小 */  
        private static final int queueCapacity = 200;  
        /** 线程池名前缀 */  
        private static final String threadNamePrefix = "Async-Service-";  
        @Bean("taskExecutor") // bean的名称，默认为首字母小写的方法名  
        public ThreadPoolTaskExecutor taskExecutor(){  
            ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();  
            executor.setCorePoolSize(corePoolSize);     
            executor.setMaxPoolSize(maxPoolSize);  
            executor.setQueueCapacity(queueCapacity);  
            executor.setKeepAliveSeconds(keepAliveTime);  
            executor.setThreadNamePrefix(threadNamePrefix);  
            // 线程池对拒绝任务的处理策略  
            // CallerRunsPolicy：由调用线程（提交任务的线程）处理该任务  
            executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());  
            // 初始化  
            executor.initialize();  
            return executor;  
        }  
    }

3.2接口

@GetMapping("/sss")
public JSONArray getIndustryOverview(String areacode) {
    service.sendMessage1();
    Future userNum3 = service.findUserNum2(areacode);
    try {
        System.err.println("获取结果");
        Object o2 = userNum3.get();
    }
    catch (Exception e) {
        e.printStackTrace();
    }
    return null;
}

3.3service

 @Service  
 public class TranTest2Service {  
    Logger log = LoggerFactory.getLogger(TranTest2Service.class);  
    // 无返回值
    @PostConstruct // 加上该注解项目启动时就执行一次该方法  
    @Async("taskExecutor")  
    public void sendMessage1() throws InterruptedException {  
        log.info("发送短信方法---- 1   执行开始");  
        Thread.sleep(5000); // 模拟耗时  
        log.info("发送短信方法---- 1   执行结束");  
    }  
      
    @Async("taskExecutor")
    public Future findUserNum2(String areacode) {
        AsyncResult<Integer> asyncResult = null;
        //一定手动开启事务
        try {
            EpointFrameDsManager.begin();
            sql = "select sum(cyrys) num from trq_userinfo where areacode=?";
            asyncResult = new AsyncResult<>(this.queryInt(sql, areacode));
            EpointFrameDsManager.commit();
        }
        catch (Exception e) {
            EpointFrameDsManager.rollback();
        }
        finally {
            EpointFrameDsManager.close();
        }
        return asyncResult;
    }
}