java多线程简介

 

 java多线程简介

     我们目前所写代码都是顺序往下执行，多个业务代码累加起来可能会非常耗时，并且拆分不易，比如同时读取数据库10个表的数据，我们假设每个表需要10s钟，那么一共需要100s钟；假如我们可以同时读取这十个表的数据，    

     在最理想情况下，一共也只需要花10s钟。

 

   多线程编程就是利用多个线程，每个线程执行对应的业务代码，来达到分拆任务，加快总体执行速度的编程方法。

 

   但是，多线程也存在其问题，那就是线程太多，线程之间来回切换也需要耗时；在对公共资源进行操作时，会经常遇到各种并发问题。

 

   Java 本身具有多线程机制，即使不涉及到具体的多线程程序编写，也会无时不刻在用它 (比如在调用main方法时已经启动了一个主线程 )。Java 的线程机制是抢占式的 ,也就是说jvm 的调度机制会周期性的（时间极短）中断当

 前某个线程，切换到另外一个线程去执行。

 

 

1 Thread和Runnable

 

   在早期我们可以使用两种方式定义并启动线程：

   继承Thread ，实现其 run方法，然后调用start方法启动线程，比如：

    public class MyThread extends Thread {

               public void run(){

System.out.println("执行线程 ");

}

}

 

       public static void main(String[] args) {

MyThread mt=new MyThread();

//启动线程

mt.start();

}

 

          注意：run方法体是实现具体业务代码的地方。

 

      也可以让Runnable 和Thread配合使用， Runnable是一个描述任务的一个接口，而 Thread则用于启动这个任务，下面我们看看怎样使用它们编写一个线程程序，

       首先必须创建一个类来实现 Runnable接口

      public class MyRunnable implements Runnable {

                   @Override

                    public void run() {

                     System.out.println("runnable");

                   }

           }

         

          然后使用 Thread对象来启动：

         Thread thread=new Thread(new MyRunnable());

thread.start();

       

 

2 线程常用API

9.3.1 Thread.sleep(2000)

        该方法表示当前线程进入休眠状态，里面传入的参数表示将要休眠的时间，这个参数的单位是毫秒，也就是说此处应该休眠 2s，同理：Thread.sleep(3000) 表示休眠 3s

      

9.3.2 Thread.currentThread()

        该方法得到当前线程对象，在调试的时候我们往往需要打印出当前的线程信息，就可以使用这个 API：

                Thread thread=Thread.currentThread();

                  System.out.println(thread.getName());

        getName() 方法可以打印出某个线程的名称

9.4 线程同步问题

    我们通常会把某个具体的业务分拆成多个业务并行执行，而这些业务往往会涉及到某些共享资源，处理好这些资源信息的同步，是我们编写多线程并发程序的一大阻碍和难点。

   

    那么，资源同步问题是怎样产生的？

               1 线程执行顺序的不确定性

    2 多个线程共享资源，并且在任务中对资源有更新和读取操作。

    下面我们通过实现一个多线程累加数值的功能来讲解线程同步问题。

   

3.1 线程同步示例

首先我们编写一个累加数值的类，这个类有一个 count属性：

     public class Const {

           private int count;

public int getCount() {

return count;

}

public void setCount(int count) {

this.count = count;

}

 

 

public void increament(){

System.out.println("加之前 "+this.count);

count++;

System.out.println("加之后 "+this.count);

}

}

然后新建一个 Runnable实现类，来调用递增方法：

public class IncreamentRunnable implements Runnable {

          private Const cnt;

public IncreamentRunnable(Const cnt){

this.cnt=cnt;

}

@Override

public  void run() {

cnt.increament();

}

 

}

这个类需要传入上面定义过的 Const类的对象，然后在run方法中调用递增方法。

 

下面我们启动多个线程来执行它：

 Const cnt=new Const();

for(int i=0;i<10;i++){

IncreamentRunnable ir=new IncreamentRunnable(cnt);

Thread thread2=new Thread(ir);

thread2.start();

}

 

注：这十个线程目前是公用的同一个 Const对象（共享资源）

 

 

我们会发现方法在执行的时候又被其他线程侵入并执行了，也就是说这个对象方法不是执行完成之后其他再执行的，而是同时都在执行，这就是所谓的线程不同步问题。

为了解决这个问题，我们可以使用 synchronized关键字使线程同步, synchronized既可以用在方法上，也可以作为方法体内的某个语句块。

     方法体上：

     public synchronized void increament()

 

 代码块：

     synchronized(this){}

   

    使用代码块级别的锁的好处是，可以自己控制锁的粒度。

  在方法上加上同步锁关键字 synchronized后，运行一下结果如下：

 

现在输出就正常了，每个方法都是执行完之后才会执行下一次。

 

3.2 wait()，notifyAll()方法

     当线程得到某个对象锁时，可以调用此对象的 wait()来使当前线程进入等待状态；当另外的线程得到某个对象锁后，此对象假如调用 notifyAll()时，就会唤醒等待在此对象上的所有线程。

          synchronized(obj){

            obj.wait();

          }

   

          synchronized(obj){

            obj.notifyAll();

    }

 

    注意：wait 和notifyAll都是 Object的方法，并且只能在锁内调用。

 

4 java5并发包的使用

   Java5/6提供了并发包，可以简化很多多线程代码，并且提供更强劲，更细致的功能，并发包在 java.util.concurrent下面，它提供了非常简单的 API来实现线程池和细粒度的并发限制等功能。

  在之前的多线程程序中，我们会给每一个任务分配一个线程，当线程的任务执行完毕后，这个线程就被销毁，这种做法在技术上没有什么问题，但是有如下缺点：

 1 线程的创建和销毁是需要很大的开销的，有可能这个开销比执行任务的开销还要大

2 线程个数不固定，会随着任务的增多而增多，而每个线程本身也是需要消耗系统资源的，假如任务过多，服务器需要创建或维护大量的线程，可能会导致系统内存空间不足

而线程池就可以解决这些问题，线程池会预先创建多个工作线程，然后让他们不断的执行某些任务，当某个线程执行完一个任务时，就会继续执行下一个任务，这样的话，线

程池中的线程就可以被重复利用，减少了创建和销毁的开销，并且线程池可以设定线程个数，不至于造成内存空间不足。

 

      
在java并发包中，创建线程池常用的大致有三种方式：

       一，根据执行的任务数自动设定线程池的大小  

            Executors.newCachedThreadPool();

 

二，根据传入的参数来设定线程大小

            Executors.newFixedThreadPool(5);

     

三，创建的线程池中只有一个线程

            Executors. SingleThreadExecutor();

 

 

Executors创建线程池时都会返回 ExecutorService 对象，我们就是通过这个执行对象来执行我们的任务。这里所说的任务，其实就是一个 Runnable实现类的对象，执行某个线程任务：

      exec.execute(Runnable 的实现类对象 )

     所以上面启动多线程程序的代码可以改为：

         Const cnt=new Const();

          ExecutorService es=Executors.newCachedThreadPool();

for(int i=0;i<10;i++){

IncreamentRunnable ir=new IncreamentRunnable(cnt);

es.execute(ir);

}

 

运行一下我们会发觉应用程序自己不会停掉，此时可以调用 shutdown()方法来停掉线程池：es.shutdown();

 

那么java 并发包是怎么处理线程同步问题的呢？

   除了之前所说的synchronized之外，可以使用并发包自带的 ReentrantLock对象，达到细粒度的锁控制

    ReentrantLock lock = new ReentrantLock(true);

    使用ReentrantLock的 lock()和unlock() 来包含需要加锁的代码块。

一般来说，会把加锁 (lock)和解锁(unlock) 的代码放在 try{}finally{}里面：

try{

          // 加锁 

          lock.lock();

System.out.println("加之前 "+this.count);

count++;

System.out.println("加之后 "+this.count);

       }finally{

          // 解锁

           lock.unlock();

  }

这是最佳实践！

 

 

 

 

   5 总结

 

     在java5 并发包之前，我们使用 Thread和Runnable 来定义并且启动线程。

 

使用synchronized 关键字来使线程同步，它既可以放在方法上，也可以放在代码块上。

 

并发包中，使用Executors来创建线程池，通过 ExecutorService对象来启动任务。

 

并发包中，可以使用ReentrantLock来创建一个锁，实现更细粒度的锁控制。