Java（多线程）

创建线程

*/
 public class ThreadDemo {
   public static void main(String[] args) {
     SubThread st = new SubThread();
     SubThread st1 = new SubThread();
     st.start();
     st1.start();
     for(int i = 0; i < 50;i++){
       System.out.println("main..."+i);
     }
   }
 }
 /*
  *  定义子类,继承Thread 
  *  重写方法run 
  */
 public class SubThread  extends Thread{
   public void run(){
     for(int i = 0; i < 50;i++){
       System.out.println("run..."+i);
     }
   }
 }

Runnable接口实现

 /*
  *  实现线程成功的另一个方式,接口实现
  *  实现接口Runnable,重写run方法
  */
 public class SubRunnable implements Runnable{
  public void run(){
    for(int i = 0 ; i < 50; i++){
      System.out.println("run..."+i);
    }
  }
 }

匿名内部类实现

*A:匿名内部类实现线程程序 
/*
 *  使用匿名内部类,实现多线程程序
 *  前提: 继承或者接口实现
 *  new 父类或者接口(){
 *     重写抽象方法
 *  }
 */
public class ThreadDemo {
  public static void main(String[] args) {
    //继承方式  XXX extends Thread{ public void run(){}}
    new Thread(){
      public void run(){
        System.out.println("!!!");
      }
    }.start();

    //实现接口方式  XXX implements Runnable{ public void run(){}}

    Runnable r = new Runnable(){
      public void run(){
        System.out.println("###");
      }
    };
    new Thread(r).start();


    new Thread(new Runnable(){
      public void run(){
        System.out.println("@@@");
      }
    }).start();

  }
}

synchronized

      /*
       *  通过线程休眠,出现安全问题
       *  解决安全问题,Java程序,提供技术,同步技术
       *  公式:
       *    synchronized(任意对象){
       *      线程要操作的共享数据
       *    }
       *    同步代码块
       */
      public class Tickets implements Runnable{

       //定义出售的票源
       private int ticket = 100;
       private Object obj = new Object();

       public void run(){
         while(true){
           //线程共享数据,保证安全,加入同步代码块
           synchronized(obj){
           //对票数判断,大于0,可以出售,变量--操作
             if( ticket > 0){
               try{
                  Thread.sleep(10);
               }catch(Exception ex){}
               System.out.println(Thread.currentThread().getName()+" 出售第 "+ticket--);
             }
           }
         }
       }
      }

Lock

/*
   *  使用JDK1.5 的接口Lock,替换同步代码块,实现线程的安全性
   *  Lock接口方法:
   *     lock() 获取锁
   *     unlock()释放锁
   *  实现类ReentrantLock
   */
  public class Tickets implements Runnable{

    //定义出售的票源
    private int ticket = 100;
    //在类的成员位置,创建Lock接口的实现类对象
    private Lock lock = new ReentrantLock();

    public void run(){
      while(true){
        //调用Lock接口方法lock获取锁
          lock.lock();
        //对票数判断,大于0,可以出售,变量--操作
          if( ticket > 0){
            try{
               Thread.sleep(10);
               System.out.println(Thread.currentThread().getName()+" 出售第 "+ticket--);
            }catch(Exception ex){

            }finally{
              //释放锁,调用Lock接口方法unlock
              lock.unlock();
            }
          }
      }
    }
  }

线程的死锁原理：多个同步

线程池

A:JDK5实现线程池
    /*
   *  JDK1.5新特性,实现线程池程序
   *  使用工厂类 Executors中的静态方法创建线程对象,指定线程的个数
   *   static ExecutorService newFixedThreadPool(int 个数) 返回线程池对象
   *   返回的是ExecutorService接口的实现类 (线程池对象)
   *   
   *   接口实现类对象,调用方法submit (Ruunable r) 提交线程执行任务
   *          
   */
  public class ThreadPoolDemo {
    public static void main(String[] args) {
      //调用工厂类的静态方法,创建线程池对象
      //返回线程池对象,是返回的接口
      ExecutorService es = Executors.newFixedThreadPool(2);
        //调用接口实现类对象es中的方法submit提交线程任务
      //将Runnable接口实现类对象,传递
      es.submit(new ThreadPoolRunnable());
      es.submit(new ThreadPoolRunnable());
      es.submit(new ThreadPoolRunnable());

    }
  }

  public class ThreadPoolRunnable implements Runnable {
    public void run(){
      System.out.println(Thread.currentThread().getName()+" 线程提交任务");
    }
  }

线程的Callable接口方式

/*
 * 使用多线程技术,求和
 * 两个线程,1个线程计算1+100,另一个线程计算1+200的和
 * 多线程的异步计算
 */
public class ThreadPoolDemo {
  public static void main(String[] args)throws Exception {
    ExecutorService es = Executors.newFixedThreadPool(2);
    Future<Integer> f1 =es.submit(new GetSumCallable(100));
    Future<Integer> f2 =es.submit(new GetSumCallable(200));
    System.out.println(f1.get());
    System.out.println(f2.get());
    es.shutdown();
  }
}



public class GetSumCallable implements Callable<Integer>{
  private int a;
  public GetSumCallable(int a){
    this.a=a;
  }

  public Integer call(){
    int sum = 0 ;
    for(int i = 1 ; i <=a ; i++){
      sum = sum + i ;
    }
    return sum;
  }
}