Java多线程例子

1. 多线程的创建方式

(1)继承 Thread类：但Thread本质上也是实现了Runnable 接口的一个实例，它代表一个线程的实例，并且，启动线程的唯一方法就是通过 Thread 类的 start()实例方法。start()方法是一个 native 方法，它将启动一个新线程，并执行run()方法。这种方式实现多线程很简单，通过自己的类直接extend Thread，并复写run()方法，就可以启动新线程并执行自己定义的run()方法。例如：继承Thread类实现多线程，并在合适的地方启动线程。

public class MyThread extends Thread {   
  public void run() {   
   System.out.println("MyThread.run()");   
  }   
}  
MyThread myThread1 = new MyThread();   
MyThread myThread2 = new MyThread();   
myThread1.start();   
myThread2.start();

(2)实现Runnable接口的方式实现多线程，并且实例化Thread，传入自己的Thread实例，调用run( )方法

public class MyThread implements Runnable {
  public void run() {
   System.out.println("MyThread.run()");
  }
}
MyThread myThread = new MyThread();
Thread thread = new Thread(myThread);
thread.start();

(3)使用ExecutorService、Callable、Future实现有返回结果的多线程：ExecutorService、Callable、Future这 个 对 象 实际 上 都是属 于 Executor 框 架中 的 功 能 类。 想 要详细 了 解 Executor 框架 的 可 以 访问http://www.javaeye.com/topic/366591 ，这里面对该框架做了很详细的解释。返回结果的线程是在JDK1.5中引入的新特征，确实很实用，有了这种特征我就不需要再为了得到返回值而大费周折了，而且即便实现了也可能漏洞百出。可返回值的任务必须实现Callable接口，类似的，无返回值的任务必须Runnable接口。执行Callable任务后，可以获取一个 Future 的对象，在该对象上调用 get 就可以获取到 Callable 任务返回的 Object 了，再结合线程池接口ExecutorService就可以实现传说中有返回结果的多线程了。下面提供了一个完整的有返回结果的多线程测试例子，在JDK1.5下验证过没问题可以直接使用。代码如下：

import java.util.concurrent.*;   
import java.util.Date;   
import java.util.List;   
import java.util.ArrayList;   
/**  
* 有返回值的线程  
*/   
@SuppressWarnings("unchecked")   
public class Test {   
public static void main(String[] args) throws ExecutionException,   
   InterruptedException {   
   System.out.println("----程序开始运行----");   
   Date date1 = new Date();      
   int taskSize = 5;   
   // 创建一个线程池   
   ExecutorService pool = Executors.newFixedThreadPool(taskSize);   
   // 创建多个有返回值的任务   
   List<Future> list = new ArrayList<Future>();   
   for (int i = 0; i < taskSize; i++) {   
    Callable c = new MyCallable(i + " ");   
    // 执行任务并获取 Future 对象   
    Future f = pool.submit(c);   
    // System.out.println(">>>" + f.get().toString());   
    list.add(f);   
   }   
   // 关闭线程池   
   pool.shutdown();      
   // 获取所有并发任务的运行结果   
   for (Future f : list) {   
    // 从 Future 对象上获取任务的返回值，并输出到控制台   
    System.out.println(">>>" + f.get().toString());   
   }      
   Date date2 = new Date();   
   System.out.println("----程序结束运行----，程序运行时间【"   
     + (date2.getTime() - date1.getTime()) + "毫秒】");   
}   
}      
class MyCallable implements Callable<Object> {   
private String taskNum;   
MyCallable(String taskNum) {   
   this.taskNum = taskNum;   
}      
public Object call() throws Exception {   
   System.out.println(">>>" + taskNum + "任务启动");   
   Date dateTmp1 = new Date();   
   Thread.sleep(1000);   
   Date dateTmp2 = new Date();   
   long time = dateTmp2.getTime() - dateTmp1.getTime();   
   System.out.println(">>>" + taskNum + "任务终止");   
   return taskNum + "任务返回运行结果,当前任务时间【" + time + "毫秒】";   58．}   
}

2.在 java 中 wait 和 sleep 方法的不同?

最大的不同是在等待时wait会释放锁，而sleep一直持有锁。wait通常被用于线程间交互，sleep通常被用于暂停执行。

3.synchronized 和 volatile 关键字的作用

一旦一个共享变量(类的成员变量、类的静态成员变量)被volatile修饰之后，那么就具备了两层语义：

(1)保证了不同线程对这个变量进行操作时的可见性，即一个线程修改了某个变量的值，这新值对其他线程来说是

立即可见的。

(2)禁止进行指令重排序。

volatile本质是在告诉jvm当前变量在寄存器(工作内存)中的值是不确定的，需要从主存中读取;

synchronized则是锁定当前变量，只有当前线程可以访问该变量，其他线程被阻塞住。

1)volatile仅能使用在变量级别;

synchronized则可以使用在变量、方法、和类级别的

2)volatile仅能实现变量的修改可见性，并不能保证原子性;

synchronized则可以保证变量的修改可见性和原子性

3)volatile不会造成线程的阻塞;

synchronized可能会造成线程的阻塞。

4)volatile标记的变量不会被编译器优化;

synchronized标记的变量可以被编译器优化

4.分析线程并发访问代码解释原因

public class Counter {
  private volatile int count = 0;
  public void inc(){
   try {
    Thread.sleep(3);
   } catch (InterruptedException e) {
    e.printStackTrace();
   }
   count++;
  }
  @Override
  public String toString() {
   return "[count=" + count + "]";
  }
 }
 public class VolatileTest {
  public static void main(String[] args) {
   final Counter counter = new Counter();
   for(int i=0;i<1000;i++){
    new Thread(new Runnable() {
     @Override
     public void run() {
      counter.inc();
     }
    }).start();
   }
   System.out.println(counter);
  }
 }

上面的代码执行完后输出的结果确定为1000吗?

答案是不一定，或者不等于1000。这是为什么吗?

在 java 的内存模型中每一个线程运行时都有一个线程栈，线程栈保存了线程运行时候变量值信息。当线程访问某一个对象时候值的时候，首先通过对象的引用找到对应在堆内存的变量的值，然后把堆内存变量的具体值load到线程本地内存中，建立一个变量副本，之后线程就不再和对象在堆内存变量值有任何关系，而是直接修改副本变量的值，在修改完之后的某一个时刻(线程退出之前)，自动把线程变量副本的值回写到对象在堆中变量。这样在堆中的对象的值就产生变化了。

也就是说上面主函数中开启了 1000 个子线程，每个线程都有一个变量副本，每个线程修改变量只是临时修改了自己的副本，当线程结束时再将修改的值写入在主内存中，这样就出现了线程安全问题。因此结果就不可能等于1000了，一般都会小于1000。

5.什么是线程池，如何使用?

线程池就是事先将多个线程对象放到一个容器中，当使用的时候就不用new线程而是直接去池中拿线程即可，节省了开辟子线程的时间，提高的代码执行效率。

在JDK的java.util.concurrent.Executors中提供了生成多种线程池的静态方法。

ExecutorService newCachedThreadPool = Executors.newCachedThreadPool(); 
ExecutorService newFixedThreadPool = Executors.newFixedThreadPool(4); 
ScheduledExecutorService newScheduledThreadPool = Executors.newScheduledThreadPool(4); 
ExecutorService newSingleThreadExecutor = Executors.newSingleThreadExecutor(); 

然后调用他们的 execute 方法即可。

6.常用的线程池有哪些?

newSingleThreadExecutor：创建一个单线程的线程池，此线程池保证所有任务的执行顺序按照任务的提交顺序执行。

newFixedThreadPool：创建固定大小的线程池，每次提交一个任务就创建一个线程，直到线程达到线程池的最大大小。

newCachedThreadPool：创建一个可缓存的线程池，此线程池不会对线程池大小做限制，线程池大小完全依赖于操作系统(或者说JVM)能够创建的最大线程大小。

newScheduledThreadPool：创建一个大小无限的线程池，此线程池支持定时以及周期性执行任务的需求。

newSingleThreadExecutor：创建一个单线程的线程池。此线程池支持定时以及周期性执行任务的需求。

7.请叙述一下您对线程池的理解?

第一：降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。

第二：提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行。

第三：提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。

8.线程池的启动策略?

官方对线程池的执行过程描述如下：

/* 
       * Proceed in 3 steps: 
       * 
       * 1. If fewer than corePoolSize threads are running, try to 
       * start a new thread with the given command as its first 
       * task.  The call to addWorker atomically checks runState and 
       * workerCount, and so prevents false alarms that would add 
       * threads when it shouldn't, by returning false. 
       * 
       * 2. If a task can be successfully queued, then we still need 
       * to double-check whether we should have added a thread 
       * (because existing ones died since last checking) or that 
       * the pool shut down since entry into this method. So we 
       * recheck state and if necessary roll back the enqueuing if 
       * stopped, or start a new thread if there are none. 
       * 
       * 3. If we cannot queue task, then we try to add a new 
       * thread.  If it fails, we know we are shut down or saturated 
       * and so reject the task. 
       */

(1)线程池刚创建时，里面没有一个线程。任务队列是作为参数传进来的。不过，就算队列里面有任务，线程池也不会马上执行它们。

(2)当调用execute() 方法添加一个任务时，线程池会做如下判断：

1)如果正在运行的线程数量小于 corePoolSize，那么马上创建线程运行这个任务;

2)如果正在运行的线程数量大于或等于 corePoolSize，那么将这个任务放入队列。

3)如果这时候队列满了，而且正在运行的线程数量小于 maximumPoolSize，那么还是要创建线程运行这个任务;

4)如果队列满了，而且正在运行的线程数量大于或等于 maximumPoolSize，那么线程池会抛出异常，告诉调用者“我不能再接受任务了”。

(3)当一个线程完成任务时，它会从队列中取下一个任务来执行。

(4)当一个线程无事可做，超过一定的时间(keepAliveTime)时，线程池会判断，如果当前运行的线程数大于corePoolSize，那么这个线程就被停掉。所以线程池的所有任务完成后，它最终会收缩到 corePoolSize 的大小。

9. 如何控制某个方法允许并发访问线程的个数?

可以使用Semaphore控制，第16行的构造函数创建了一个Semaphore对象，并且初始化了5个信号。这样的效果是控件 test 方法最多只能有 5 个线程并发访问，对于 5 个线程时就排队等待，走一个来一下。第 33行，请求一个信号(消费一个信号)，如果信号被用完了则等待，第45行释放一个信号，释放的信号新的线程就可以使用了。

以上就是星辉小编介绍的"Java多线程例子"，希望对大家有帮助，如有疑问，请在线咨询，有专业老师随时为您服务。