线程小结1

1 线程的两类java声明实现方式
   A 继承Thread
   B 实现runnable
    例子
    public class TestThread1 {
 public static void main(String args[]) {
  Runner1 r = new Runner1();
  r.start();
  
  //Thread t = new Thread(r);
  //t.start();
  
  for(int i=0; i<100; i++) {
   System.out.println("Main Thread:------" + i);
  }
 }
}

//class Runner1 implements Runnable {
class Runner1 extends Thread {
 public void run() {
  for(int i=0; i<100; i++) { 
   System.out.println("Runner1 :" + i);
  }
 }
}
 
2  sleep用法
    import java.util.*;
public class TestSleep {
  public static void main(String[] args) {
    MyThread thread = new MyThread();
    thread.start();
    try {Thread.sleep(10000);}
    catch (InterruptedException e) {}
    thread.interrupt();
  }
}

class MyThread extends Thread {
 boolean flag = true;
  public void run(){
    while(flag){
      System.out.println("==="+new Date()+"===");
      try {
        sleep(1000);
      } catch (InterruptedException e) {
        return;
      }
    }
  }
}

3  join:等子线程执行完后，主线程再执行
   public class TestJoin {
  public static void main(String[] args) {
    MyThread2 t1 = new MyThread2("abcde");
    t1.start();
    try {
     t1.join();
    } catch (InterruptedException e) {}
     
    for(int i=1;i<=10;i++){
      System.out.println("i am main thread");
    }
  }
}
class MyThread2 extends Thread {
  MyThread2(String s){
   super(s);
  }
 
  public void run(){
    for(int i =1;i<=10;i++){
      System.out.println("i am "+getName());
      try {
       sleep(1000);
      } catch (InterruptedException e) {
       return;
      }
    }
  }
}

4 yield(),让出线程给其他
   public class TestYield {
  public static void main(String[] args) {
    MyThread3 t1 = new MyThread3("t1");
    MyThread3 t2 = new MyThread3("t2");
    t1.start(); t2.start();
  }
}
class MyThread3 extends Thread {
  MyThread3(String s){super(s);}
  public void run(){
    for(int i =1;i<=100;i++){
      System.out.println(getName()+": "+i);
      if(i%10==0){
        yield();
      }
    }
  }

5 线程优先级
  
  public class TestPriority {
 public static void main(String[] args) {
  Thread t1 = new Thread(new T1());
  Thread t2 = new Thread(new T2());
  t1.setPriority(Thread.NORM_PRIORITY + 3);
  t1.start();
  t2.start();
 }
}

class T1 implements Runnable {
 public void run() {
  for(int i=0; i<1000; i++) {
   System.out.println("T1: " + i);
  }
 }
}

class T2 implements Runnable {
 public void run() {
  for(int i=0; i<1000; i++) {
   System.out.println("------T2: " + i);
  }
 }
}

6 线程的synchronized.
    public class TestSync implements Runnable {
  Timer timer = new Timer();
  public static void main(String[] args) {
    TestSync test = new TestSync();
    Thread t1 = new Thread(test);
    Thread t2 = new Thread(test);
    t1.setName("t1");
    t2.setName("t2");
    t1.start();
    t2.start();
  }
  public void run(){
    timer.add(Thread.currentThread().getName());
  }
}

class Timer{
  private static int num = 0;
  public synchronized void add(String name){
   //synchronized (this) {
     num ++;
     try {Thread.sleep(1);}
     catch (InterruptedException e) {}
     System.out.println(name+", 你是第"+num+"个使用timer的线程");
   //}
  }
}

  注意，这里由于t1,t2两个线程，都会同时使用到公共资源区timer，因此会发生不同步的问题，必须要加上synchronized

7 死锁的例子
   public class TestDeadLock implements Runnable {
 public int flag = 1;
 static Object o1 = new Object(), o2 = new Object();
 public void run() {
System.out.println("flag=" + flag);
  if(flag == 1) {
   synchronized(o1) {
    try {
     Thread.sleep(500);
    } catch (Exception e) {
     e.printStackTrace();
    }
    synchronized(o2) {
     System.out.println("1"); 
    }
   }
  }
  if(flag == 0) {
   synchronized(o2) {
    try {
     Thread.sleep(500);
    } catch (Exception e) {
     e.printStackTrace();
    }
    synchronized(o1) {
     System.out.println("0");
    }
   }
  }
 } 
 
 public static void main(String[] args) {
  TestDeadLock td1 = new TestDeadLock();
  TestDeadLock td2 = new TestDeadLock();
  td1.flag = 1;
  td2.flag = 0;
  Thread t1 = new Thread(td1);
  Thread t2 = new Thread(td2);
  t1.start();
  t2.start();
  
 }
}

8 要注意的，比如如下程序
   public class Sync implements Runnable {
 int b = 100;
 
 public synchronized void m1() throws Exception{
  //Thread.sleep(2000);
  b = 1000;
  Thread.sleep(5000);
  System.out.println("b = " + b);
 }
 
 public synchronized void m2() throws Exception {
  Thread.sleep(2500);
  b = 2000;
 }
 
 public void run() {
  try {
   m1();
  } catch(Exception e) {
   e.printStackTrace();
  }
 }
 
 public static void main(String[] args) throws Exception {
  Sync tt = new Sync();
  Thread t = new Thread(tt);
  t.start();
  
  tt.m2();
  System.out.println(tt.b);
 }
}
 输出：1000
        b=1000
    因为启动m2后，获得锁，之后释放后，由m1来执行，最后b=1000.
   如果public void m2() throws Exception {
   则b=2000了，一直都是b=2000最后

 
9  生产者，消费者问题
    public class ProducerConsumer {
 public static void main(String[] args) {
  SyncStack ss = new SyncStack();
  Producer p = new Producer(ss);
  Consumer c = new Consumer(ss);
  new Thread(p).start();
  new Thread(p).start();
  new Thread(p).start();
  new Thread(c).start();
 }
}

class WoTou {
 int id;
 WoTou(int id) {
  this.id = id;
 }
 public String toString() {
  return "WoTou : " + id;
 }
}

class SyncStack {
 int index = 0;
 WoTou[] arrWT = new WoTou[6];
 
 public synchronized void push(WoTou wt) {
  while(index == arrWT.length) {
   try {
    this.wait();
   } catch (InterruptedException e) {
    e.printStackTrace();
   }
  }
  this.notifyAll();  
  arrWT[index] = wt;
  index ++;
 }
 
 public synchronized WoTou pop() {
  while(index == 0) {
   try {
    this.wait();
   } catch (InterruptedException e) {
    e.printStackTrace();
   }
  }
  this.notifyAll();
  index--;
  return arrWT[index];
 }
}

class Producer implements Runnable {
 SyncStack ss = null;
 Producer(SyncStack ss) {
  this.ss = ss;
 }
 
 public void run() {
  for(int i=0; i<20; i++) {
   WoTou wt = new WoTou(i);
   ss.push(wt);
System.out.println("生产了：" + wt);
   try {
    Thread.sleep((int)(Math.random() * 200));
   } catch (InterruptedException e) {
    e.printStackTrace();
   }   
  }
 }
}

class Consumer implements Runnable {
 SyncStack ss = null;
 Consumer(SyncStack ss) {
  this.ss = ss;
 }
 
 public void run() {
  for(int i=0; i<20; i++) {
   WoTou wt = ss.pop();
System.out.println("消费了: " + wt);
   try {
    Thread.sleep((int)(Math.random() * 1000));
   } catch (InterruptedException e) {
    e.printStackTrace();
   }   
  }
 }
}