pool.execute(new Runnable(){}) 什么用法？
[ 本帖最后由 赵江锋 于 2011-09-24  20:08 编辑 ]

创建线程有两种方法：继承Thread类和实现Runnable接口。

方法一：继承 Thread 类，覆盖方法 run()，我们在创建的 Thread 类的子类中重写 run() ,加入线程所要执行的代码即可。下面是一个例子：
public class MyThread extends Thread {
int count= 1, number;
public MyThread(int num) {
number = num;
System.out.println("创建线程 " + number);
}
public void run() {
while(true) {
System.out.println("线程 " + number + ":计数 " + count);
if(++count== 6) return;
}
}
public static void main(String args[]) {
for(int i = 0; i < 5; i++) new MyThread(i+1).start();
}
}

方法二：实现 Runnable 接口
  Runnable 接口只有一个方法 run()，我们声明自己的类实现 Runnable 接口并提供这一方法，将我们的线程代码写入其中，就完成了这一部分的任务。但是 Runnable 接口并没有任何对线程的支持，我们还必须创建 Thread 类的实例，这一点通过 Thread 类的构造函数public Thread(Runnable target);来实现。下面是一个例子：
public class MyThread implements Runnable {
int count= 1, number;
public MyThread(int num) {
number = num;
System.out.println("创建线程 " + number);
}
public void run() {
while(true) {
System.out.println("线程 " + number + ":计数 " + count);
if(++count== 6) return;
}
}
public static void main(String args[]) {
for(int i = 0; i < 5; i++) new Thread(new MyThread(i+1)).start();
}
}
  两种方法各有千秋，可以灵活运用。

你说的new Runnable(){} 这种是一个匿名内部类的写法，Runnable是一个接口，里面只有一个run方法，代表线程要执行的任务，如果我们没有定义一个类去继承它，那么要new它的子类对象时，就要使用你提问的那种匿名内部类的方法。
还有你把Runnable写成了 Runnbale这是错的。

这是我看了张孝祥老师的视频教程的学习笔记，希望对你有帮助

public class ThreadEstablish {  
  /**
* 线程创建的种形式
*/   
    public static void main(String[] args) {     
   /** 第一种：实现Thread的子类 **/

   Thread thread1 = new Thread(){  
    //重写了Thread类的run();      
   @Override      
   public void run() {  
       System.out.println("thread1 is running :" + Thread.currentThread().getName());            
      }      
  };      
  thread1.start();   
     /* *第二种：
      */      
Thread thread2 = new Thread(new Runnable(){   
     @Override         
    public void run() {   
       System.out.println("thread2 is running :" + Thread.currentThread().getName());         
     }      
  });      
      thread2.start();
    //以上看不出线程的效果，可以加以修改      
    //不写Thread.sleep(500);也行，写了更容易观察效果   
    /** 第一种：实现Thread的子类 */  
    Thread thread3 = new Thread(){   
   //重写了Thread类的run();  
      @Override      
      public void run() {  
      while(true){
       try {   
             Thread.sleep(500);   
         } catch (InterruptedException e) {
            e.printStackTrace();   
          }            
        System.out.println("thread3 is running :" + Thread.currentThread().getName());   
            }
           }   
     };      
  thread3.start();     
       /* *第二种：
         */      
  Thread thread4 = new Thread(new Runnable(){
           @Override     
       public void run() {  
              while(true){   
                 try {   
                    Thread.sleep(500);   
                } catch (InterruptedException e) {  
                      e.printStackTrace();   
                 }   
           System.out.println("thread4 is running :" + Thread.currentThread().getName());      
          }  
          }   
                 });  
      thread4.start();   
            /* * 第二种方式更能体现面向对象的思想
               * 一个是线程对象thread，线程对象要运行代码runnable，      
              */                              


           /* * 第三种也是第四种（这是一个组合，便于比较）  
              * 思考下面的那个线程会跑起来
              */
       new Thread(new Runnable(){
           @Override   
        public void run() {
               while(true){  
                  try {      
                  Thread.sleep(500);   
                } catch (InterruptedException e) {  
                      e.printStackTrace();   
                 }   
                System.out.println("runnable is running :" + Thread.currentThread().getName());     
           }   
        }   
                 }){   
        @Override     
       public void run() {  
              while(true){   
                try {     
                   Thread.sleep(500);   
                } catch (InterruptedException e) {  
                      e.printStackTrace();     
               }     
               System.out.println("thread is running :" + Thread.currentThread().getName());      
          }   
        }  
      }.start();  
        /** 我们知道实现Thread的子类重写了run方法，那么父类的run就失效了，而runnable调用的就是父类的run      
          * 如果不重写就找runnable，重写了就按重写的跑     
            * 具体请查看jdk   
          * 因此这里就只跑了thread is running  
          */      
      }
}
[ 本帖最后由 丁朋伟 于 2011-09-24  14:28 编辑 ]