Java 多线程项目实战

项目中其实很多方面都要用多线程，前提说一下多线程一些实现和介绍，最后项目实力，废话不多说，开始

创建线程有哪几种方式？

• 继承Thread类创建线程类。
• 通过Runnable接口类创建线程类。
• 通过Callable和Future创建线程。

说一下 runnable 和 callable 有什么区别？

1）Runnable提供run方法，不会抛出异常，只能在run方法内部处理异常。Callable提供call方法，直接抛出Exception异常，也就是你不会因为call方法内部出现检查型异常而不知所措，完全可以抛出即可。
2）Runnable的run方法无返回值，Callable的call方法提供返回值用来表示任务运行的结果
3）Runnable可以作为Thread构造器的参数，通过开启新的线程来执行，也可以通过线程池来执行。而Callable只能通过线程池执行。

线程有哪些状态？

• NEW： 新建状态，线程对象已经创建，但尚未启动
• RUNNABLE:就绪状态，可运行状态，调用了线程的start方法，已经在java虚拟机中执行，等待获取操作系统资源如CPU，操作系统调度运行。
• Running：就绪状态的线程获取到了CPU
• BLOCKED:堵塞状态。线程等待锁的状态，等待获取锁进入同步块/方法或调用wait后重新进入需要竞争锁
• WAITING：等待状态。等待另一个线程以执行特定的操作。调用以下方法进入等待状态。 Object.wait(), Thread.join(),LockSupport.park
• TIMED_WAITING: 线程等待一段时间。调用带参数的Thread.sleep, objct.wait,Thread.join，LockSupport.parkNanos,LockSupport.parkUntil
• TERMINATED:进程结束状态。

sleep() 和 wait() 有什么区别？

• 每个对象都有一个锁来控制同步访问，Synchronized关键字可以和对象的锁交互，来实现同步方法或同步块。sleep()方法正在执行的线程主动让出CPU，在sleep指定时间后CPU再回到该线程继续往下执行（注意：sleep方法只让出了CPU，而并不会释放同步资源锁！！！);wait()方法则是指当前线程让自己暂时退让出同步资源锁，以便其他正在等待该资源的线程得到该资源进而运行，只有调用了notify()方法，之前调用wait()的线程才会解除wait状态，可以去参与竞争同步资源锁，进而得到执行。（注意：notify的作用相当于叫醒睡着的人，而并不会给他分配任务，就是说notify只是让之前调用wait的线程有权利重新参与线程的调度）；
• sleep()方法可以在任何地方使用；wait()方法则只能在同步方法或同步块中使用；
• sleep()是线程线程类（Thread）的方法，调用会暂停此线程指定的时间，但监控依然保持，不会释放对象锁，到时间自动恢复；wait()是Object的方法，调用会放弃对象锁，进入等待队列，待调用notify()/notifyAll()唤醒指定的线程或者所有线程，才会进入锁池，再次获得对象锁才会进入运行状态；
• sleep()方法必须捕获异常，而wait()、notify（）、notifyAll（）不需要捕获异常。

线程的 run()和 start()有什么区别？

run()相当于线程的任务处理逻辑的入口方法，它由Java虚拟机在运行相应线程时直接调用，而不是由应用代码进行调用。
而start()的作用是启动相应的线程。启动一个线程实际是请求Java虚拟机运行相应的线程，而这个线程何时能够运行是由线程调度器决定的。start()调用结束并不表示相应线程已经开始运行，这个线程可能稍后运行，也可能永远也不会运行。start()会先调用JVM_StartThread，再调用thread_entry，最后调用run()。

-------------------------------------------------------------------------------------------------------------------------------------------------

废话不多说项目实例

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.Future;



public class ThreadTask implements Callable<List<obj>>{
    private List<obj> firstList;
    private List<obj> secondList;
    private List<obj> thirdList;
    private Integer type = 0;

    
    public ThreadTask (List<> firstList,List<CredtRaPO> secondList,List<> thirdList){
        this.firstList = firstList;
        this.secondList = secondList;
        this.thirdList=thirdList;
        this.type = 0;
    }
    


    @Override
    public List<BondPO> call() throws Exception {
        // TODO Auto-generated method stub
      
            for (BondPO bondPO : firstList) {
                
                String bondId = bondPO.getBondId();
                ArrayList<CredtRaPO> CredtRaPOListarr = new ArrayList<>();
                ArrayList<> unifysctycrdtcdepoarr = new ArrayList<>();
                for (CredtRaPO credtRaPO : secondList) {
                    
                    if(bondId.equals(obj.getBondBscInfoId())){
                     CredtRaPOListarr.add(credtRaPO);
                    }
                
                }
                bondPO.setCredtRaPOList(CredtRaPOListarr);
                
                String issrId = obj.getIssrId();
                for (obj obj: thirdList) {
                   if(issrId.equals(obj.getPubCompuuid())){
                    unifysctycrdtcdepoarr.add(obj);
                      }
               }
                   obj.setUnifySctyCrdtCdePOList(unifysctycrdtcdepoarr);
               }
                
              
   
        return firstList;
    }

}

 

  

    private Page<BondPO> findPage( OrderBy orderBy, int pageSize, int pageNo, GroupBy groupBy) {
        Page<obj> ipage = new Page<obj>();
     
      
            
            //线程池（future,callable）
            //固定大小线程池
            ExecutorService threadPool = new ThreadPoolExecutor(5, 100,
                    0, TimeUnit.SECONDS,
                    new ArrayBlockingQueue<>(512), // 使用有界队列，避免OOM
                    new ThreadPoolExecutor.DiscardPolicy());
            //线程管理mapList<CredtRaPO>
             List<Future<List<obj>>> futureList = new ArrayList<Future<List<obj>>>();
             List<obj> CredtRaPOList = getSqlSessionTemplate().selectList(getNamespace() + ".findPagezxpj");
             List<obj> UnifySctyCrdtCdePOList = getSqlSessionTemplate().selectList(getNamespace() + ".findPageFxr");
            for (int i = 0; i % 10000 == 0; i+=10000) {
                //查询
                int pageSizes=i+10000;
                int pageNos=i;
                System.out.println(i);
                int startRow = pageSizes * (pageNos - 1) + 1;
                int endRow = pageSizes * pageNos;
                int offset = pageSizes * (pageNos - 1);
                params.put("startRow", Integer.valueOf(i));
                params.put("endRow", Integer.valueOf(i+10000));
                params.put("offset", (i > 0) ? i+1:0);//三目运算符);
                params.put("limit", 10000);
                List<BondPO> poitems = getSqlSessionTemplate().selectList(getNamespace() + ".findPage", params);
                if(poitems.size()==0){
                    break;
                }
                
                ThreadTask task1 = new ThreadTask(poitems,CredtRaPOList,UnifySctyCrdtCdePOList);
                Future<List<BondPO>> future1 = threadPool.submit(task1);
                
                futureList.add(future1);
                
                //开线程
                //做计算，同时拿到返回的线程类
                //线程类添加到管理map中
            }
            //遍历线程管理map拿到当前开启的每一个线程
            //调用get方法获取线程执行结果
            //汇总多个线程的计算结果
            List<BondPO> poitemsss=new ArrayList<BondPO>();
            for(Future<List<BondPO>> future:futureList){
                try {
                    List<BondPO> list = future.get();
                    for (BondPO bondPO : list) {
                        poitemsss.add(bondPO);
                    }
             
                    
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                } catch (ExecutionException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            //关闭线程池
            threadPool.shutdown();
            
            
      
            
            
            ipage.setPageList(poitemsss);

      
        }
        // 2 return
        return ipage;
    }