Java Thread Runnable

ThreadDemo1.java

public class ThreadDemo1 
{ 
	public static void main(String [] args) 
	{ 
		TestThread t=new TestThread(); 
		// 一个线程对象只能启动一次
		t.start();
		t.start();
		t.start();
		t.start();
	} 
} 

class TestThread extends Thread 
{ 
	private int tickets=20; 
	public void run() 
	{ 
		while(true) 
		{ 
			if(tickets>0) 
				System.out.println(Thread.currentThread().getName()+"出售票"+tickets--); 
		} 
	} 
} 
输出结果：
Exception in thread "main" java.lang.IllegalThreadStateException 
at java.lang.Thread.start(Native Method) 
at ThreadDemo9_3.main(ThreadDemo9_3.java:8) 
Thread-0出售票20 
Thread-0出售票19 
Thread-0出售票18 
Thread-0出售票17 
Thread-0出售票16 
Thread-0出售票15 
Thread-0出售票14 
Thread-0出售票13 
Thread-0出售票12 
Thread-0出售票11 
Thread-0出售票10 
Thread-0出售票9 
Thread-0出售票8 
Thread-0出售票7 
Thread-0出售票6
Thread-0出售票5 
Thread-0出售票4 
Thread-0出售票3 
Thread-0出售票2 
Thread-0出售票1 

ThreadDemo2.java

public class ThreadDemo2
{
	public static void main(String []args)
	{
		// 启动了四个线程，分别执行各自的操作
		new TestThread().start(); 
		new TestThread().start();
		new TestThread().start();
		new TestThread().start(); 
	}
}

class TestThread extends Thread
{
	private int tickets = 20;
	
	public void run()
	{
		try
		{
			while(true)
			{
				if(tickets > 0)
					System.out.println(Thread.currentThread().getName()+" 出售票 "+tickets--);
			}
		}
		catch (Exception e)
		{
			System.out.println(e);
		}
	}
}
输出结果：
Thread-3出售票5 
Thread-2出售票4 
Thread-3出售票4 
Thread-2出售票3 
Thread-3出售票3 
Thread-1出售票2 
Thread-2出售票2 
Thread-1出售票1 
Thread-2出售票1 
Thread-3出售票2 
Thread-3出售票1 
Thread-0出售票12 
Thread-0出售票11 
Thread-0出售票10 
Thread-0出售票9 
Thread-0出售票8 
Thread-0出售票7 
Thread-0出售票6 
Thread-0出售票5 
Thread-0出售票4 
Thread-0出售票3 
Thread-0出售票2 
Thread-0出售票1 

ThreadDemo3.java

public class ThreadDemo3
{
	public static void main(String []args)
	{
		TestThread = new TestThread();
		// 启动了四个线程，分别执行各自的操作
		new Thread(t).start(); 
		new Thread(t).start();
		new Thread(t).start();
		new Thread(t).start(); 
	}
}

class TestThread implements Runnable
{
	private int tickets = 20;
	
	public void run()
	{
		try
		{
			while(true)
			{
				if(tickets > 0)
					System.out.println(Thread.currentThread().getName()+" 出售票 "+tickets--);
			}
		}
		catch (Exception e)
		{
			System.out.println(e);
		}
	}
}
输出结果：
Thread-1出售票20 
Thread-1出售票19 
Thread-1出售票18 
Thread-1出售票17 
Thread-1出售票16 
Thread-1出售票15 
Thread-1出售票14 
Thread-1出售票13 
Thread-2出售票12 
Thread-3出售票11 
Thread-4出售票10 
Thread-2出售票9 
Thread-3出售票8 
Thread-4出售票7 
Thread-2出售票6 
Thread-3出售票5 
Thread-4出售票4 
Thread-2出售票3 
Thread-3出售票2 
Thread-4出售票1
从程序的输出结果来看，尽管启动了四个线程对象，但是结果都是操纵了同一个资源，实现了资源共享的目的。

可见，实现Runnable接口相对于继承Thread类来说，有如下显著的优势：
(1)适合多个相同程序代码的线程去处理同一资源的情况，把虚拟CPU（线程）同程序的代码、数据有效分离，较好地体现了面向对象的设计思想。
(2)可以避免由于Java的单继承特性带来的局限。开发中经常碰到这样一种情况，即：当要将已经继承了某一个类的子类放入多线程中，由于一个类不能同时有两个父类，
所以不能用继承Thread类的方式，那么就只能采用实现Runnable接口的方式了。
(3)增强了程序的健壮性，代码能够被多个线程共享，代码与数据是独立的。当多个线程的执行代码来自同一个类的实例时，即称它们共享相同的代码。多个线程可以操作
相同的数据，与它们的代码无关。当共享访问相同的对象时，即共享相同的数据。当线程被构造时，需要的代码和数据通过一个对象作为构造函数实参传递进去，这个对
象就是一个实现了Runnable接口的类的实例。
事实上，几乎所有多线程应用都可用第二种方式，即实现Runnable接口。

线程五种状态：新建、就绪、运行、阻塞和终止。
BLOCKED:受阻塞并且正在等待监视器锁的某一线程的线程状态。
NEW:至今尚未启动的线程的状态。
RUNNABLE:可运行线程的线程状态。
TERMINATED:已终止线程的线程状态。
TIMED_WAITING:具有指定等待时间的某一等待线程的线程状态。
WAITING:某一等待线程的线程状态。 

public class InterruptCheck //线程的中断
{ 
	public static void main(String[] args)  
	{ 
		Thread t = Thread.currentThread(); 
		System.out.println("A：t.isInterrupted() = " + t.isInterrupted()); 
		t.interrupt(); 
		System.out.println("B：t.isInterrupted() = " + t.isInterrupted()); 
		System.out.println("C：t.isInterrupted() = " + t.isInterrupted()); 
		
		try 
		{ 
			Thread.sleep(2000); 
			System.out.println("线程没有被中断！"); 
		} 
		catch( InterruptedException x) 
		{ 
			System.out.println("线程被中断！"); 
		} 
		// 因为sleep抛出了异常，所以它清除了中断标志
		System.out.println("D：t.isInterrupted() = " + t.isInterrupted()); 
	} 
} 

A：t.isInterrupted() = false
B：t.isInterrupted() = true
C：t.isInterrupted() = true
线程被中断！
D：t.isInterrupted() = false

程序说明：
1、 程序第5行通过Thread类中的currentThread()方法，取得当前运行的线程，因为此代码是在main()方法之中运行，所以当前的线程就为main()线程。
2、 程序第6行，因为没有调用中断方法，所以此时线程未中断，但在第7行调用了中断方法，所以之后的线程状态都为中断。
3、 程序第11行，让线程开始休眠，但此时线程已经被中断，所以这个时候会抛出中断异常，抛出中断异常之后，会清除中断标记，所以最后在判断是
否中断的时候，会返回线程未中断。

多线程的同步

… 
synchronized(对象) 
{ 
需要同步的代码; 
} 
… 


public class TicketTest
{
	public static void main(String []args)
	{
		Ticket t = new Ticket();
		new Thread(t).start(); 
		new Thread(t).start();
		new Thread(t).start();
		new Thread(t).start(); 
	}
}

class Ticket implemets Runnable
{
	private int tickets = 20;
	
	public void run()
	{
		while(true)
		{
			synchronized(this)
			{
				if(tickets > 0)
				{
					try
					{
						Thread.sleep(100);
					}
					catch(Exception e)
					{
					}
					System.out.println(Thread.currentThread().getName()+" 出售票 "+tickets--);
				}
			}
		}
	}
}

除了可以对代码块进行同步外，也可以对函数实现同步，只要在需要同步的函数定义前加上synchronized关键字即可。

访问控制符synchronized 返回值类型 方法名称(参数) 
{ 
…. ; 
}

class TestThread implements Runnable
{ 
    private int tickets=20; 
    
    public void run() 
    { 
        while(true) 
        { 
            sale() ; 
        } 
    } 
    public synchronized void sale() 
    { 
        if(tickets>0) 
        { 
            try
            { 
                Thread.sleep(100); 
            } 
            catch(Exception e)
            {} 

            System.out.println(Thread.currentThread().getName()+"出售票"+tickets--); 
        } 
    } 
}

死锁
一旦有多个进程，且它们都要争用对多个锁的独占访问，那么就有可能发生死锁。如果有一组进程或线程，其中每个都在等待一个只有其它进程或线程才可以
执行的操作，那么就称它们被死锁了。