public Thread(Runnable target,String name)

public final synchronized void setName(String name)

public final String getName()

class MyThread implements Runnable{
	@Override
	public void run() {
		for(int i=0;i<5;i++)
		{
			//currentThread()方法用于取得當(dāng)前正在JVM中運行的線程
			//使用getName()方法，用于獲取線程的名稱
			System.out.println("當(dāng)前線程："+Thread.currentThread().getName()+"-----i="+i);
		}
	}
}
public class Test1 {
	public static void main(String[] args){
		//創(chuàng)建線程對象thread1且沒有設(shè)置線程名稱
		MyThread myThread1=new MyThread();
		Thread thread1=new Thread(myThread1);
		thread1.start();
		//創(chuàng)建線程對象thread2且使用setName設(shè)置線程名稱
		MyThread myThread2=new MyThread();
		Thread thread2=new Thread(myThread2);
		thread2.setName("線程2");
		thread2.start();
		//創(chuàng)建線程對象thread3并在創(chuàng)建線程時設(shè)置線程名稱
		MyThread myThread3=new MyThread();
		Thread thread3=new Thread(myThread3,"線程3");
		thread3.start();
	}
}

public static native void sleep(long millis) throws InterruptedException;

class MyThread implements Runnable{
	@Override
	public void run() {
		for(int i=0;i<5;i++)
		{
			//使用Thread類的sleep()方法，讓線程處于休眠狀態(tài)
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println("當(dāng)前線程："+Thread.currentThread().getName()+"-----i="+i);
		}
	}
}
public class Test1 {
	public static void main(String[] args){
		MyThread myThread=new MyThread();
		//利用myThread對象分別創(chuàng)建三個線程
		Thread thread1=new Thread(myThread);
		thread1.start();
		Thread thread2=new Thread(myThread);
		thread2.start();
		Thread thread3=new Thread(myThread);
		thread3.start();
	}
}

public static native void yield();

class MyThread implements Runnable{
	@Override
	public void run() {
		for(int i=0;i<5;i++)
		{
			//使用Thread類的yield()方法
			Thread.yield();
			System.out.println("當(dāng)前線程："+Thread.currentThread().getName()+"-----i="+i);
		}
	}
}
public class Test1 {
	public static void main(String[] args){
		MyThread myThread=new MyThread();
		//利用myThread對象分別創(chuàng)建三個線程
		Thread thread1=new Thread(myThread);
		thread1.start();
		Thread thread2=new Thread(myThread);
		thread2.start();
		Thread thread3=new Thread(myThread);
		thread3.start();
	}
}

 public final void join() throws InterruptedException {
        join(0);
    }

class MyThread implements Runnable{
	@Override
	public void run() {
		for(int i=0;i<2;i++)
		{
			//使用Thread類的sleep()方法
			try {
				Thread.sleep(3000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println("當(dāng)前線程："+Thread.currentThread().getName()+"-----i="+i);
		}
	}
}
public class Test1 {
	public static void main(String[] args) throws InterruptedException{
		MyThread myThread=new MyThread();
		Thread thread1=new Thread(myThread,"自己創(chuàng)建的線程");
		thread1.start();
		System.out.println("主線程："+Thread.currentThread().getName());
		//線程對象thread1調(diào)用join()方法
		thread1.join();
		System.out.println("代碼結(jié)束");
	}
}

class MyThread implements Runnable{
	//設(shè)置標(biāo)記位
	private boolean flag=true;
	public void setFlag(boolean flag) {
		this.flag = flag;
	}
	@Override
	public void run() {
		int i=0;
		while(flag)
		{
			System.out.println("第"+(i++)+"次執(zhí)行-----"+"線程名稱:"+Thread.currentThread().getName());
		}
	}
}
public class Test1 {
	public static void main(String[] args) throws InterruptedException{
		MyThread myThread=new MyThread();
		Thread thread1=new Thread(myThread,"自己創(chuàng)建的線程");
		thread1.start();
		//讓主線程sleep一毫秒
		Thread.sleep(1);
		//修改標(biāo)記位的值，讓自己創(chuàng)建的線程停止
		myThread.setFlag(false);
		System.out.println("代碼結(jié)束");
	}
}

class MyThread implements Runnable{
	@Override
	public void run() {
		for(int i=0;i<100;i++)
		{
			System.out.println("線程名稱:"+Thread.currentThread().getName()+"------i="+i);
		}
	}
}
public class Test1 {
	public static void main(String[] args) throws InterruptedException{
		MyThread myThread=new MyThread();
		Thread thread1=new Thread(myThread,"自己創(chuàng)建的線程");
		thread1.start();
		//讓主線程sleep一毫秒
		Thread.sleep(1);
		//調(diào)用已被棄用的stop()方法去強制讓線程退出
		thread1.stop();
		System.out.println("代碼結(jié)束");
	}
}

public synchronized void fun(){
	x=3;
	y=4;
}

class MyThread implements Runnable{
	@Override
	public void run() {
		int i=0;
		while(true)
		{
			//使用sleep()方法，使得線程由運行狀態(tài)轉(zhuǎn)換為阻塞狀態(tài)
			try {
				Thread.sleep(1000);
				//調(diào)用isInterrupted()方法，用于判斷當(dāng)前線程是否被中斷
				boolean bool=Thread.currentThread().isInterrupted();
				if(bool) {
					System.out.println("非阻塞狀態(tài)下執(zhí)行該操作，當(dāng)前線程被中斷!");
					break;
				}
				System.out.println("第"+(i++)+"次執(zhí)行"+" 線程名稱："+Thread.currentThread().getName());
			} catch (InterruptedException e) {
				System.out.println("退出了！");
				//這里退出了阻塞狀態(tài)，且中斷標(biāo)志bool被系統(tǒng)自動清除設(shè)置為false，所以此處的bool為false
				boolean bool=Thread.currentThread().isInterrupted();
				System.out.println(bool);
				//退出run()方法，中斷進程
				return;
			}
		}
	}
}
public class Test1 {
	public static void main(String[] args) throws InterruptedException{
		MyThread myThread=new MyThread();
		Thread thread1=new Thread(myThread,"自己創(chuàng)建的線程");
		thread1.start();
		//讓主線程sleep三秒
		Thread.sleep(3000);
		//調(diào)用interrupt()方法
		thread1.interrupt();
		 System.out.println("代碼結(jié)束");
	}
}

public final void wait() throws InterruptedException {
        wait(0);
    }

public class Test1 {
	public static void main(String[] args) {
		Object object=new Object();
		synchronized (object) {
			System.out.println("調(diào)用wait()前");
			//調(diào)用Object類的wait()方法
			try {
				object.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println("調(diào)用wait()后");
		}
	} 
}

public final native void notify();

class MyThread implements Runnable{
	private boolean flag;
	private Object object;
	//定義一個構(gòu)造方法
	public MyThread(boolean flag,Object object) {
		this.flag=flag;
		this.object=object;
	}
	//定義一個普通方法,其中調(diào)用了wait()方法
	public void waitThread() {
		synchronized (this.object) {
			try {
				System.out.println("調(diào)用wait()前------"+Thread.currentThread().getName());
				//調(diào)用wait()方法
				this.object.wait();
				System.out.println("調(diào)用wait()后------"+Thread.currentThread().getName());
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
	//定義一個普通方法,其中調(diào)用了notify()方法
	public void notifyThread() {
		synchronized (this.object) {
			try {
				System.out.println("調(diào)用notify前------"+Thread.currentThread().getName());
				//調(diào)用notify()方法
				this.object.notify();
				System.out.println("調(diào)用notify()后------"+Thread.currentThread().getName());
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
	}
	@Override
	public void run() {
		if(this.flag) {
			this.waitThread();
		}else {
			this.notifyThread();
		}
	}	
}
public class Test1 {
	public static void main(String[] args) {
		Object object=new Object();
		//實例化調(diào)用wait()的線程
		MyThread wait=new MyThread(true,object);
		Thread waitThread=new Thread(wait,"wait線程");
		//實例化調(diào)用notify()的線程
		MyThread notify=new MyThread(false,object);
		Thread notifyThread=new Thread(notify,"notify線程");
		//啟動線程
		waitThread.start();
		//調(diào)用一下sleep()方法，使得查看效果更明顯
		try {
			Thread.sleep(2000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		notifyThread.start();
	} 
}

class MyThread implements Runnable{
	private boolean flag;
	private Object object;
	//定義一個構(gòu)造方法
	public MyThread(boolean flag,Object object) {
		this.flag=flag;
		this.object=object;
	}
	//定義一個普通方法,其中調(diào)用了wait()方法
	public void waitThread() {
		synchronized (this.object) {
			try {
				System.out.println("調(diào)用wait()前------"+Thread.currentThread().getName());
				//調(diào)用wait()方法
				this.object.wait();
				System.out.println("調(diào)用wait()后------"+Thread.currentThread().getName());
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
	//定義一個普通方法,其中調(diào)用了notify()方法
	public void notifyThread() {
		synchronized (this.object) {
			try {
				System.out.println("調(diào)用notify前------"+Thread.currentThread().getName());
				//調(diào)用notify()方法
				this.object.notify();
				System.out.println("調(diào)用notify()后------"+Thread.currentThread().getName());
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
	}
	@Override
	public void run() {
		if(this.flag) {
			this.waitThread();
		}else {
			this.notifyThread();
		}
	}	
}
public class Test1 {
	public static void main(String[] args) {
		Object object=new Object();
		//實例化調(diào)用wait()的線程
		MyThread wait=new MyThread(true,object);
		Thread waitThread1=new Thread(wait,"wait線程1");
		Thread waitThread2=new Thread(wait,"wait線程2");
		Thread waitThread3=new Thread(wait,"wait線程3");
		//實例化調(diào)用notify()的線程
		MyThread notify=new MyThread(false,object);
		Thread notifyThread=new Thread(notify,"notify線程");
		//啟動3個等待線程
		waitThread1.start();
		waitThread2.start();
		waitThread3.start();
		//調(diào)用一下sleep()方法，使得查看效果更明顯
		try {
			Thread.sleep(2000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		notifyThread.start();
	} 
}

public final native void notifyAll();

class MyThread implements Runnable{
	private boolean flag;
	private Object object;
	//定義一個構(gòu)造方法
	public MyThread(boolean flag,Object object) {
		this.flag=flag;
		this.object=object;
	}
	//定義一個普通方法,其中調(diào)用了wait()方法
	public void waitThread() {
		synchronized (this.object) {
			try {
				System.out.println("調(diào)用wait()前------"+Thread.currentThread().getName());
				//調(diào)用wait()方法
				this.object.wait();
				System.out.println("調(diào)用wait()后------"+Thread.currentThread().getName());
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
	//定義一個普通方法,其中調(diào)用了notifyAll()方法
	public void notifyThread() {
		synchronized (this.object) {
			try {
				System.out.println("調(diào)用notify前------"+Thread.currentThread().getName());
				//調(diào)用notifyAll()方法
				this.object.notifyAll();
				System.out.println("調(diào)用notify()后------"+Thread.currentThread().getName());
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
	}
	@Override
	public void run() {
		if(this.flag) {
			this.waitThread();
		}else {
			this.notifyThread();
		}
	}	
}
public class Test1 {
	public static void main(String[] args) {
		Object object=new Object();
		//實例化調(diào)用wait()的線程
		MyThread wait=new MyThread(true,object);
		Thread waitThread1=new Thread(wait,"wait線程1");
		Thread waitThread2=new Thread(wait,"wait線程2");
		Thread waitThread3=new Thread(wait,"wait線程3");
		//實例化調(diào)用notifyAll()的線程
		MyThread notify=new MyThread(false,object);
		Thread notifyThread=new Thread(notify,"notify線程");
		//啟動3個等待線程
		waitThread1.start();
		waitThread2.start();
		waitThread3.start();
		//調(diào)用一下sleep()方法，使得查看效果更明顯
		try {
			Thread.sleep(2000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		notifyThread.start();
	} 
}

class MyThread extends Thread{
	public void run(){
		System.out.println("線程運行");
	}
}
public class Test{
	public static void main(String[] args){
		MyThread thread=new MyThread();
		thread.start();//開啟線程
	}
}

class Runna implements Runnable
{
	public void run(){
		System.out.println("線程運行");
	}
}
public class Test{
	public static void main(String[] args){
		Runna runna=new Runna();
		Thread t=new Thread(runna);
		t.start();//開啟線程
	}
}

public class ThreadDemo03 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub

        Callable<Object> oneCallable = new Tickets<Object>();
        FutureTask<Object> oneTask = new FutureTask<Object>(oneCallable);

        Thread t = new Thread(oneTask);

        System.out.println(Thread.currentThread().getName());

        t.start();

    }

}

class Tickets<Object> implements Callable<Object>{

    //重寫call方法
    @Override
    public Object call() throws Exception {
        // TODO Auto-generated method stub
        System.out.println(Thread.currentThread().getName()+"-->我是通過實現(xiàn)Callable接口通過FutureTask包裝器來實現(xiàn)的線程");
        return null;
    }   
}

public class ThreadDemo05{

    private static int POOL_NUM = 10;     //線程池數(shù)量

    /**
     * @param args
     * @throws InterruptedException 
     */
    public static void main(String[] args) throws InterruptedException {
        // TODO Auto-generated method stub
        ExecutorService executorService = Executors.newFixedThreadPool(5);  
        for(int i = 0; i<POOL_NUM; i++)  
        {  
            RunnableThread thread = new RunnableThread();

            //Thread.sleep(1000);
            executorService.execute(thread);  
        }
        //關(guān)閉線程池
        executorService.shutdown(); 
    }   

}

class RunnableThread implements Runnable  
{     
    @Override
    public void run()  
    {  
        System.out.println("通過線程池方式創(chuàng)建的線程：" + Thread.currentThread().getName() + " ");  

    }  
}