public class Deom_1 extends Thread{

  public void run(){
      super.run();
      System.out.println("MyThread01");
    }


  public static void main(String[] args){
    Deom_1 demo=new Deom_1();
    demo.setName("Demo_1");
    demo.start();
    System.out.println("當(dāng)前線程的名字:"+Thread.currentThread().getName()+" 運(yùn)行結(jié)束");
  }
}

//通過實(shí)現(xiàn)Runnable接口來創(chuàng)建線程類
public class SecondThread implements Runnable
{
  private int i ;
  //run方法同樣是線程執(zhí)行體
  public void run()
  {
    for ( ; i < 20 ; i++ )
    {
      //當(dāng)線程類實(shí)現(xiàn)Runnable接口時(shí)，
      //如果想獲取當(dāng)前線程，只能用Thread.currentThread()方法。
      System.out.println(Thread.currentThread().getName() + " " + i);
    }
  }

  public static void main(String[] args) 
  {
    for (int i = 0; i < 50; i++)
    {
      System.out.println(Thread.currentThread().getName() + " " + i);
      if (i == 20)
      {
        SecondThread st = new SecondThread();
        //通過new Thread(target , name)方法創(chuàng)建新線程
        new Thread(st , "新線程1").start();
        new Thread(st , "新線程2").start();
      }
    }
  }
}

PriorityTest low = new PriorityTest("低級(jí)");
low.start();
System.out.println("創(chuàng)建之初的優(yōu)先級(jí):" + low.getPriority());
//設(shè)置該線程為最低優(yōu)先級(jí)
low.setPriority(Thread.MIN_PRIORITY);

PriorityTest high = new PriorityTest("高級(jí)");
high.start();
System.out.println("創(chuàng)建之初的優(yōu)先級(jí):" + high.getPriority());
//設(shè)置該線程為最高優(yōu)先級(jí)
high.setPriority(Thread.MAX_PRIORITY);

class SelfPrivateNum {
  private int num = 0;

  public void addI(String username) {
    try {

      if (username.equals("a")) {
        num = 100;
        System.out.println("a set over!");
        Thread.sleep(2000);
      } else {
        num = 200;
        System.out.println("b set over!");
      }
      System.out.println(username + " num=" + num);
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
  }

}

class ThreadAA extends Thread {

  private SelfPrivateNum numRef;

  public ThreadAA(SelfPrivateNum numRef) {
    super();
    this.numRef = numRef;
  }

  @Override
  public void run() {
    super.run();
    numRef.addI("a");
  }

}

class ThreadBB extends Thread {

  private SelfPrivateNum numRef;

  public ThreadBB(SelfPrivateNum numRef) {
    super();
    this.numRef = numRef;
  }

  @Override
  public void run() {
    super.run();
    numRef.addI("b");
  }

}

public class RunUnsafe {

  public static void main(String[] args) {

    SelfPrivateNum numRef = new SelfPrivateNum();

    ThreadAA athread = new ThreadAA(numRef);
    athread.start();

    ThreadBB bthread = new ThreadBB(numRef);
    bthread.start();

  }

}

class SelfPrivateNum2 {
  private int num = 0;

  public synchronized void addI(String username) {
    try {

      if (username.equals("a")) {
        num = 100;
        System.out.println("a set over!");
        Thread.sleep(2000);
      } else {
        num = 200;
        System.out.println("b set over!");
      }
      System.out.println(username + " num=" + num);
    } catch (InterruptedException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }
  }

}

//線程開始執(zhí)行同步代碼塊之前，必須先獲得對(duì)同步監(jiān)控器的鎖定
synchronized (Obj){
  ………
  //此處的代碼就是同步代碼塊  
}

Class A{
   private final ReentrantLock lock= new ReentrantLock ();
   //需要保證線程安全的方法
   public void m(){
    //加鎖
    lock.lock();
    try{  
      ……………
    }
    finally{
     lock.unlock();
    }
  }
}   

public class Test3 {
  //main方法中有三個(gè)等待線程，一個(gè)喚醒線程，一個(gè)喚醒線程只能喚醒一個(gè)等待線程，程序出現(xiàn)阻塞
  public static void main(String[] args) throws InterruptedException {

    Object lock = new Object();

    ThreadA a = new ThreadA(lock);
    new ThreadA(lock).start();
    new ThreadA(lock).start();
    new ThreadA(lock).start();

    Thread.sleep(1000);

    NotifyThread notifyThread = new NotifyThread(lock);
    notifyThread.start();

  }

}

class ThreadA extends Thread {
  private Object lock;

  public ThreadA(Object lock) {
    super();
    this.lock = lock;
  }

  @Override
  public void run() {
    Service service = new Service();
    service.testMethod(lock);
  }

}

class NotifyThread extends Thread {
  private Object lock;

  public NotifyThread(Object lock) {
    super();
    this.lock = lock;
  }

  @Override
  public void run() {
    synchronized (lock) {
      //notify()只能喚醒一個(gè)線程，nofiyAll()喚醒所有的等待線程
      lock.notify();
//     lock.notifyAll();
    }
  }

}

class Service {

  public void testMethod(Object lock) {
    try {
      synchronized (lock) {
        System.out.println("begin wait() ThreadName="
            + Thread.currentThread().getName());
        lock.wait();
        System.out.println(" end wait() ThreadName="
            + Thread.currentThread().getName());
      }
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
  }

}

public class Account
{
  //顯示定義Lock對(duì)象
  private final Lock lock = new ReentrantLock();
  //獲得指定Lock對(duì)象對(duì)應(yīng)的條件變量
  private final Condition cond = lock.newCondition(); 

  private String accountNo;
  private double balance;

  //標(biāo)識(shí)賬戶中是否已經(jīng)存款的旗標(biāo)
  private boolean flag = false;

  public Account(){}

  public Account(String accountNo , double balance)
  {
    this.accountNo = accountNo;
    this.balance = balance;
  }

  public void setAccountNo(String accountNo)
  {
    this.accountNo = accountNo;
  }
  public String getAccountNo()
  {
     return this.accountNo;
  }

  public double getBalance()
  {
     return this.balance;
  }
  public void draw(double drawAmount)
  {
    //加鎖
    lock.lock();
    try
    {
      //如果賬戶中還沒有存入存款，該線程等待
      while(!flag)
      {
        cond.await();
      }
        //執(zhí)行取錢操作
        System.out.println(Thread.currentThread().getName() + 
          " 取錢:" + drawAmount);
        balance -= drawAmount;
        System.out.println("賬戶余額為：" + balance);
        //將標(biāo)識(shí)是否成功存入存款的旗標(biāo)設(shè)為false
        flag = false;
        //喚醒該Lock對(duì)象對(duì)應(yīng)的其他線程
        cond.signalAll();
    }
    catch (InterruptedException ex)
    {
      ex.printStackTrace();
    }
    //使用finally塊來確保釋放鎖
    finally
    {
      lock.unlock();
    }
  }
  public void deposit(double depositAmount)
  {
    lock.lock();
    try
    {
      //如果賬戶中已經(jīng)存入了存款，該線程等待
      while(flag)
      {
        cond.await();        
      }

        //執(zhí)行存款操作
        System.out.println(Thread.currentThread().getName() + 
          " 存款:" + depositAmount);
        balance += depositAmount;
        System.out.println("賬戶余額為：" + balance);
        //將標(biāo)識(shí)是否成功存入存款的旗標(biāo)設(shè)為true
        flag = true;
        //喚醒該Lock對(duì)象對(duì)應(yīng)的其他線程
        cond.signalAll();
    }
    catch (InterruptedException ex)
    {
      ex.printStackTrace();
    }
    //使用finally塊來確保釋放鎖
    finally
    {
      lock.unlock();
    }
  }

  public int hashCode()
  {
    return accountNo.hashCode();
  }
  public boolean equals(Object obj)
  {
    if (obj != null && obj.getClass() == Account.class)
    {
      Account target = (Account)obj;
      return target.getAccountNo().equals(accountNo);
    }
    return false;
  }
}

import java.util.concurrent.*;

class RtnThread implements Callable<Integer>
{
  //實(shí)現(xiàn)call方法，作為線程執(zhí)行體
  public Integer call()
  {
    int sum = 0;
    int i=0;
    for ( ; i < 10 ; i++ )
    {
      System.out.println(Thread.currentThread().getName()+ " 的循環(huán)變量i的值：" + i); 
      sum+=i;
    }
    //call()方法可以有返回值

    return sum;
  }
} 

public class CallableTest
{
  public static void main(String[] args) 
  {
    //創(chuàng)建Callable對(duì)象
    RtnThread rt = new RtnThread();
    //使用FutureTask來包裝Callable對(duì)象
    FutureTask<Integer> task = new FutureTask<Integer>(rt);
    for (int i = 0 ; i < 10 ; i++)
    {
      System.out.println(Thread.currentThread().getName()
        + " 的循環(huán)變量i的值：" + i);
      if (i == 5)
      {
        //實(shí)質(zhì)還是以Callable對(duì)象來創(chuàng)建、并啟動(dòng)線程
        new Thread(task , "有返回值的線程").start();
      }
    }
    try
    {
      //獲取線程返回值
      System.out.println("子線程的返回值：" + task.get());          
    }
    catch (Exception ex)
    {
      ex.printStackTrace();
    }
  }
}

import java.util.concurrent.*;

//實(shí)現(xiàn)Runnable接口來定義一個(gè)簡(jiǎn)單的
class TestThread implements Runnable
{
  public void run()
  {
    for (int i = 0; i < 10 ; i++ )
    {
      System.out.println(Thread.currentThread().getName()
        + "的i值為:" + i);
    }
  }
}

public class ThreadPoolTest
{
  public static void main(String[] args) 
  {
    //創(chuàng)建一個(gè)具有固定線程數(shù)（6）的線程池
    ExecutorService pool = Executors.newFixedThreadPool(6);
    //向線程池中提交3個(gè)線程
    pool.execute(new TestThread());
    Future f1=pool.submit(new TestThread());
    Future f2=pool.submit(new TestThread());

    Future<Integer> f3=pool.submit(new RtnThread());

    try
    {
      if(f1.get()==null&&f2.get()==null&&f3.get()!=null){
        System.out.println("執(zhí)行完畢！");
        System.out.println(f3.get());

      }
      //獲取線程返回值

    }
    catch (Exception ex)
    {
      ex.printStackTrace();
    }
    //關(guān)閉線程池
    pool.shutdown();
  }
}