Spring 线程池

java中线程池实现

方式一
package com.toltech.springboot.test;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @author Wgs
 * @version 1.0
 * @create：2017/11/27
 */


 class MyRunnables implements Runnable {

    @Override
    public void run() {
        for (int x = 0; x < 100; x++) {
            System.out.println(Thread.currentThread().getName() + ":" + x);
        }
    }

}


/*
 * 线程池的好处：线程池里的每一个线程代码结束后，并不会死亡，而是再次回到线程池中成为空闲状态，等待下一个对象来使用。
 *
 * 如何实现线程的代码呢?
 *      A:创建一个线程池对象，控制要创建几个线程对象。
 *          public static ExecutorService newFixedThreadPool(int nThreads)
 *      B:这种线程池的线程可以执行：
 *          可以执行Runnable对象或者Callable对象代表的线程
 *          做一个类实现Runnable接口。
 *      C:调用如下方法即可
 *          Future<?> submit(Runnable task)
 *          <T> Future<T> submit(Callable<T> task)
 *      D:我就要结束，可以吗?
 *          可以。
 */
public class ExecutorsDemo {
    public static void main(String[] args) {
        // 创建一个线程池对象，控制要创建几个线程对象。
        // public static ExecutorService newFixedThreadPool(int nThreads)
        ExecutorService pool = Executors.newFixedThreadPool(2);

        // 可以执行Runnable对象或者Callable对象代表的线程
        pool.submit(new MyRunnables());
        pool.submit(new MyRunnables());

        //结束线程池
        pool.shutdown();
    }
}
方式二
package com.toltech.springboot.test;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @author Wgs
 * @version 1.0
 * @create：2017/11/27
 */
/*
 * 多线程实现的方式3：
 *      A:创建一个线程池对象，控制要创建几个线程对象。
 *          public static ExecutorService newFixedThreadPool(int nThreads)
 *      B:这种线程池的线程可以执行：
 *          可以执行Runnable对象或者Callable对象代表的线程
 *          做一个类实现Runnable接口。
 *      C:调用如下方法即可
 *          Future<?> submit(Runnable task)
 *          <T> Future<T> submit(Callable<T> task)
 *      D:我就要结束，可以吗?
 *          可以。
 */
public class CallableDemo {
    public static void main(String[] args) {
        //创建线程池对象
        ExecutorService pool = Executors.newFixedThreadPool(2);

        //可以执行Runnable对象或者Callable对象代表的线程
        pool.submit(new MyCallable());
        pool.submit(new MyCallable());

        //结束
        pool.shutdown();
    }
}

//Callable:是带泛型的接口。
//这里指定的泛型其实是call()方法的返回值类型。
 class MyCallable implements Callable {

    @Override
    public Object call() throws Exception {
        for (int x = 0; x < 100; x++) {
            System.out.println(Thread.currentThread().getName() + ":" + x);
        }
        return null;
    }

}

Spring

ApplicationContext.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/tx
        http://www.springframework.org/schema/tx/spring-tx.xsd">

    <!--自动扫描-->
    <context:component-scan base-package="com.wanggs">
        <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>

    <!--数据库连接池-->
    <context:property-placeholder location="classpath:config.properties"/>

    <bean id="dataSource" class="org.apache.commons.dbcp2.BasicDataSource" destroy-method="close">
        <property name="driverClassName" value="${jdbc.driver}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>


    <!--事务管理器-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>

    <!--基于注解的事务-->
    <tx:annotation-driven transaction-manager="transactionManager"/>

    <!--MyBatis-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <property name="typeAliasesPackage" value="com.wanggs.pojo"/>
        <property name="mapperLocations" value="classpath:mapper/*.xml"/>
        <property name="configuration">
            <bean class="org.apache.ibatis.session.Configuration">
                <property name="mapUnderscoreToCamelCase" value="true"/>
            </bean>
        </property>
    </bean>

    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.wanggs.mapper"/>
    </bean>


    <!--邮件处理-->
    <bean id="javaMailSender" class="org.springframework.mail.javamail.JavaMailSenderImpl">
        <property name="host" value="${mail.host}"/>
        <property name="username" value="${mail.username}"/>
        <property name="password" value="${mail.password}"/>
        <property name="javaMailProperties">
            <props>
                <prop key="mail.smtp.auth">true</prop>
            </props>
        </property>
    </bean>
    <!--线程池-->
    <bean id="taskExecutor" class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor">
        <property name="corePoolSize" value="10"/>
        <property name="maxPoolSize" value="20"/>
        <property name="queueCapacity" value="20"/>
    </bean>
    <!--redis连接池的配置-->
    <bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
        <property name="maxTotal" value="${redis.pool.maxActive}"/>
        <property name="maxIdle" value="${redis.pool.maxIdle}"/>
        <property name="minIdle" value="${redis.pool.minIdle}"/>
        <property name="maxWaitMillis" value="${redis.pool.maxWait}"/>
        <property name="testOnBorrow" value="${redis.pool.testOnBorrow}"/>
        <property name="testOnReturn" value="${redis.pool.testOnReturn}"/>
    </bean>
    <bean id="jedisPool" class="redis.clients.jedis.JedisPool">
        <constructor-arg index="0" ref="jedisPoolConfig"/>
        <constructor-arg index="1" value="${redis.host}" />
        <constructor-arg index="2" value="${redis.port}" />
        <constructor-arg index="3" value="${redis.timeout}" />
        <!--Redis密码-->
        <constructor-arg index="4" name="password" value="#{'${redis.password}'!=''?'${redis.password}':null}" />
    </bean>
</beans>
image.png
package com.wanggs.task;

import com.google.common.cache.Cache;
import com.google.common.cache.CacheBuilder;
import com.wanggs.mapper.UserMapper;
import com.wanggs.pojo.User;
import com.wanggs.statu.ActiveStatus;
import org.apache.commons.lang.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.mail.javamail.JavaMailSender;
import org.springframework.mail.javamail.MimeMessageHelper;
import org.springframework.mail.javamail.MimeMessagePreparator;
import org.springframework.stereotype.Service;

import javax.mail.internet.MimeMessage;
import java.util.concurrent.TimeUnit;


/**
 * @author Wgs
 * @version 1.0
 * @create：2017/11/28
 */
@Service
public class MailTask implements Runnable {
    @Autowired
    private UserMapper userMapper;
    private static Logger LOG = LoggerFactory.getLogger(MailTask.class);
    // 邮件缓存,发送激活用户的邮件,写进去时间,如果没有人访问就过期,有人访问就延长时间
    private static Cache<String, String> cache = CacheBuilder.newBuilder()
            .expireAfterWrite(6, TimeUnit.HOURS)
            .build();
    private String code;
    private String email;
    private JavaMailSender javaMailSender;
    private int operation;
    public MailTask() {
    }

    public MailTask(String code, String email, JavaMailSender javaMailSender, int operation) {
        this.code = code;
        this.email = email;
        this.javaMailSender = javaMailSender;
        this.operation = operation;
    }

    @Override
    public void run() {
        javaMailSender.send(new MimeMessagePreparator() {
            @Override
            public void prepare(MimeMessage mimeMessage) throws Exception {
                LOG.info("开始发送邮件~");
                MimeMessageHelper mimeMessageHelper = new MimeMessageHelper(mimeMessage, true, "UTF-8");
                mimeMessageHelper.setFrom("ceshihahu@yeah.net");
                mimeMessageHelper.setTo(email);
                mimeMessageHelper.setSubject("一封激活邮件~");

                String url = "http://localhost:8083/user/";
                StringBuffer sb = new StringBuffer();
                sb.append("<html><head></head><body>");
                if (operation == 1) {
                    sb.append("<a href=" + url + "activate.do?code=");
                    sb.append(code);
                    sb.append(">点击激活</a></body>");
                } else {
                   String newPassword = code.substring(0,8);
                   cache.put("newPassword",newPassword);
                    sb.append("是否将您的密码修改为:");
                    sb.append(newPassword);
                    sb.append("，<a href=" + url + "verify.do?code=" + code + ">");
                    sb.append("点击是</a></body>");
                }

                // 放入缓存
                cache.put(code, email);

                mimeMessageHelper.setText(sb.toString(), true);

                LOG.info("发送邮寄结束~");

            }
        });
    }

    /**
     * 验证token
     *
     * @param code
     */
    public String active(String code,String flg) {
        String email = cache.getIfPresent(code);
        // code 是否正确 是否过期 验证数据库是否存在 更新数据库 删除缓存
        if (email == null) {
            return "token过期或者无效";
        }
        User user = userMapper.selectByEmail(email);
        if (user == null) {
            return "帐号不存在";
        }else {
            user.setActived(ActiveStatus.ACTIVE.getValue());
            if (StringUtils.isBlank(flg)) {
                userMapper.updateActived(user);
            }else {
                String newPassword = cache.getIfPresent("newPassword");
                user.setPassword(newPassword);
                userMapper.updatePassword(user);
                // 删除缓存
                cache.invalidate("newPassword");
            }
           // 删除缓存中键对应的值
           cache.invalidate(code);
           LOG.info("帐号已经激活~");
        }

        return "ok";
    }
}
©著作权归作者所有,转载或内容合作请联系作者
平台声明：文章内容（如有图片或视频亦包括在内）由作者上传并发布，文章内容仅代表作者本人观点，简书系信息发布平台，仅提供信息存储服务。

推荐阅读更多精彩内容

  • Spring Cloud
    Spring Cloud为开发人员提供了快速构建分布式系统中一些常见模式的工具（例如配置管理，服务发现，断路器，智...
    卡卡罗2017阅读 135,026评论 19赞 139
  • Spring boot参考指南
    Spring Boot 参考指南 介绍 转载自:https://www.gitbook.com/book/qbgb...
    毛宇鹏阅读 46,974评论 6赞 342
  • Java初级面试题
    1. Java基础部分 基础部分的顺序：基本语法，类相关的语法，内部类的语法，继承相关的语法，异常的语法，线程的语...
    子非鱼_t_阅读 31,780评论 18赞 399
  • 男护并不稀缺
    我是毕业于卫校的一名男护士。知道的人都说抢手货啊。确实毕业之后被爸妈抢到了手两个月来我去一家招聘信息说需要五名护理...
    痞纸蓝阅读 192评论 0赞 0
  • 积极主动
    今天写简书有些晚了，要不是和大家的约定。今天这片简书肯定不写了。今天感觉过的特别快，不知不觉已经到这个点了，好久没...
    杨荣鹏阅读 316评论 2赞 1