线程和线程池的相关问题记录

卖票举例 thread的使用举例
//      MyThreadmt1 = new MyThread();
//      MyThreadmt2 = new MyThread();
//      MyThreadmt3 = new MyThread();
//      mt1.start();//每个线程都各卖了10张，共卖了30张票
//      mt2.start();//但实际只有10张票，每个线程都卖自己的票
//      mt3.start();//没有达到资源共享

输出结果，三个线程各卖了10张票，共30张

        MyThread1mt=new MyThread1();
        new Thread(mt).start();
        new Thread(mt).start();
        new Thread(mt).start();

输出结果，三个线程共卖了10张票，共10张
 
    class MyThread
extends Thread {
//      privateint ticket = 10;
//
//      publicvoid run() {
//          for(int i = 0; i < 20; i++) {
//              if(this.ticket > 0) {
//                  System.out.println("卖票：ticket" + this.ticket--);
//              }
//          }
//      }
    };
    class MyThread1
implements Runnable{
        private
int ticket = 10;
        public
void run() {
            for (int i = 0; i < 20; i++){
                if (this.ticket > 0) {
                    System.out.println("卖票：ticket" +
this.ticket--);
                }
            }
        }
    };

继承thread类线程内部的变量在各个线程间独立的（private
int
ticket = 10;）不共享的
实现runnable接口的类资源各个线程间是可以（private
int ticket = 10;）共享的。

如果thread类线程和runnable接口中的资源（变量）是全局资源，那么都是共享的。

 

以下是四种线程池。

    ExecutorServicepool = Executors.newSingleThreadExecutor();
创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。（顺序）
//  2.  ExecutorService pool =Executors.newCachedThreadPool();
创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。（并发）
//      3.ExecutorServicepool = Executors.newFixedThreadPool(1);
创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。（并发）
 
pool.execute((new MyThread()));
pool.execute((new MyThread1()));
pool.execute((new MyThread2()));
pool.execute((new MyThread3()));
   
 
4.创建一个定长线程池，支持定时及周期性任务执行。延迟执行示例代码如下
 

1.      ScheduledExecutorService pool = Executors.newScheduledThreadPool(5);  
2.     scheduledThreadPool.schedule(new Runnable() {  
3.      public void run() {  
4.       System.out.println("delay 3 seconds");  
5.      }  
6.     }, 3, TimeUnit.SECONDS);  

表示延迟3秒执行。
 

1.   ScheduledExecutorService pool = Executors.newScheduledThreadPool(5);  
2.     scheduledThreadPool.scheduleAtFixedRate(new Runnable() {  
3.      public void run() {  
4.       System.out.println("delay 1 seconds, and excute every 3 seconds");  
5.      }  
6.     }, 1, 3, TimeUnit.SECONDS);  

表示延迟1秒后每3秒执行一次。

    class MyThread
extends Thread implements Runnable{
        private
int ticket = 0;
//
        public
void run() {
//          for(int i = 0; i < 20; i++) {
//              if(this.ticket > 0) {
                    Log.e("aaa",
"卖票：ticket" +
this.ticket);
                    System.out.println("卖票：ticket" +
this.ticket);
                }
//          }
//      }
    };
    class MyThread1
extends Thread implements Runnable{
        private
int ticket = 1;
//
        public
void run() {
//          for(int i = 0; i < 20; i++) {
//              if(this.ticket > 0) {
                    Log.e("aaa",
"卖票：ticket" +
this.ticket);
                    System.out.println("卖票：ticket" +
this.ticket);
                }
//          }
//      }
    };
    class MyThread2
extends Thread implements Runnable{
        private
int ticket = 2;
//
        public
void run() {
//          for(int i = 0; i < 20; i++) {
//              if(this.ticket > 0) {
            Log.e("aaa",
"卖票：ticket" +
this.ticket);
                    System.out.println("卖票：ticket" +
this.ticket);
                }
//          }
//      }
    };
    class MyThread3
extends Thread implements Runnable{
        private
int ticket = 3;
//
        public
void run() {
//          for(int i = 0; i < 20; i++) {
//              if(this.ticket > 0) {
            Log.e("aaa",
"卖票：ticket" +
this.ticket);
                    System.out.println("卖票：ticket" +
this.ticket);
                }
//          }
//      }
    };