线程的基本了解
1、线程的实现方式
线程有两种实现方式，分别为继承Thread、实现Runnable接口。差异性：实现方式避免了类的继承单一性，且对于多个线程同时访问同一个资源时更便捷。
（1）继承Thread
class TestThread extends Thread { @Override public void run() { for (int i = 0; i <= 100; i++) { System.out.println(Thread.currentThread().getName()+":"+i); } } } public class TestThreadMethod { public static void main(String[] args) { TestThread th1 = new TestThread(); th1.setName("testThread"); th1.start(); } }
（2）实现Runnable接口
class TestRunnable implements Runnable{ @Override public void run() { for (int i=1; i <= 100; i++) { System.out.println(Thread.currentThread().getName() + ":" + i); } } } public class TestMain { public static void main(String[] args) { TestRunnable tr = new TestRunnable(); Thread th1 = new Thread(tr, "th1"); Thread th2 = new Thread(tr, "th2"); th1.start(); th2.start(); } }
（3）线程的生命周期
2、线程的常用方法
start()：线程的开启。同一个线程在结束时只能开启一次，否则报错。
setName()：设置当前线程的名称。
getName()：获取当前线程的名称。
currentThread()：获取当前线程的对象。
priority()：线程的级别。静态值有，0/5(默认)/10。值越高，代表争夺CPU的使用权的几率越大，但不是绝对。
yield()：线程让步。当前线程A调用yield()方法时，释放CPU的使用权，重新与其他线程B争夺CPU的使用权。
join()：线程加入。在A线程中，调用B线程的join方法时，A线程的程序等待B线程的程序执行完才能继续执行A线程。
sleep()：线程睡眠。当线程执行该方法时，进入设置的睡眠时间后继续执行程序。
isAlive()：线程是否在活动，返回值为boolean。
wait()：线程等待。必须在同步方法中使用。
notify()/notifyAll()：线程唤醒，与wait()结合使用，用于线程通信。
注意：（1）线程在同步时，wait()会释放锁，而join()与sleep()方法不会释放锁。
（2）wait()、notify()、notifyAll()严格来说不算线程中的方法，这三个方法是定义在Object对象中。
class TestThread extends Thread { @Override public void run() { for (int i = 0; i <= 100; i++) { System.out.println(Thread.currentThread().getName()+":"+i); } } } public class TestThreadMethod { public static void main(String[] args) { TestThread th1 = new TestThread(); th1.setName("testThread"); th1.setPriority(Thread.MAX_PRIORITY); th1.start(); Thread.currentThread().setName("=======mainThread"); for (int i = 0; i <= 100; i++) { System.out.println(Thread.currentThread().getName() + ":" + i); if (i % 10 == 0) { Thread.yield(); } if (i == 20) { try { th1.join(); System.out.println(th1.isAlive()); th1.start(); } catch (InterruptedException e) { e.printStackTrace(); } } } } }
3、线程的同步
线程的同步分为两种：同步代码块和同步方法块。
class TestThread extends Thread { static int ticket = 100; static Object obj = new Object(); @Override public void run() { /*1、同步代码块时，只能同步需要的代码块，其余无关代码块不行，会影响同步； * 2、同步监视器用this，代表当前对象，此时继承方式，对象是多个，所以无法同步； * 此两种情况出现重复输出情况，如下的this情况 */ /*synchronized (this) { while(true) { try { Thread.currentThread().sleep(100); } catch (InterruptedException e) { // TODaO Auto-generated catch block e.printStackTrace(); } if (ticket <= 0) { break; } System.out.println(Thread.currentThread().getName() + "窗口:" +ticket--); } }*/ while(true) { synchronized (obj) {//obj充当锁时必须是静态的，否则多个对象代表的锁是各自的。 try { Thread.currentThread().sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } if (ticket <= 0) { break; } System.out.println(Thread.currentThread().getName() + "窗口:" +ticket--); } } } } public class TestMain { public static void main(String[] args) { TestThread th1 = new TestThread(); TestThread th2 = new TestThread(); th1.setName("th1"); th2.setName("th2"); th1.start(); th2.start(); } }
class TestThread implements Runnable { int ticket = 100; @Override public void run() { while(true) { importNum(); } } /** * 同步方法块时，同步锁为当前对象.所以方法的类必须是同一个对象 */ private synchronized void importNum() { if (ticket <= 0) { return; } System.out.println(Thread.currentThread().getName() + "窗口:" + ticket--); } } public class TestMain { public static void main(String[] args) { TestThread th = new TestThread(); Thread th1 = new Thread(th, "th1"); Thread th2 = new Thread(th, "th2"); th1.start(); th2.start(); } }
注：同步在Thread与Runnable两种方式的实现中有很大的区别，详见上例。
拓展示例：
class SingleTon { private SingleTon() { } public static SingleTon instance = null; public static SingleTon getSingleTon() { /** * 原程序直接判断，创建实例，返回。在多线程中，存在线程安全问题，会创建多个SingleTon; * 开发中为避免这情况发生，采用下面同步的实现方式。 */ /** if (instance == null) { instance = new SingleTon(); } return instance; */ if (instance == null) {//提高同步效率，后面访问方法的对象，无需再次等待 synchronized(SingleTon.class) {//采用类本身的对象来充当锁 if (instance == null) { instance = new SingleTon(); } } } return instance; } } public class TestMain { public static void main(String[] args) { SingleTon st1 = SingleTon.getSingleTon(); SingleTon st2 = SingleTon.getSingleTon(); } }
4、线程的死锁
死锁：当两个线程同时需要对方手中的锁时，各自都在等对方放弃手中的锁，而使程序无限期的等待下去，称为死锁。
public class TestMain { public static void main(String[] args) { StringBuffer sb1 = new StringBuffer(); StringBuffer sb2 = new StringBuffer(); new Thread(){ public void run() { synchronized(sb1) { sb1.append("A"); try { Thread.currentThread().sleep(10); } catch (InterruptedException e) { e.printStackTrace(); } synchronized(sb2) { sb2.append("B"); System.out.println("sb1:" + sb1.toString()); System.out.println("sb2:" + sb2.toString()); } } }; }.start(); new Thread(){ public void run() { synchronized(sb2) { sb2.append("C"); try { Thread.currentThread().sleep(10); } catch (InterruptedException e) { e.printStackTrace(); } synchronized(sb1) { sb1.append("D"); System.out.println("sb1:" + sb1.toString()); System.out.println("sb2:" + sb2.toString()); } } }; }.start(); } }
上述例子中，第一个线程执行第一个同步块代码后，进行睡眠，握住sb1的锁；此时第二个线程可能已经开启运行，获取sb2的锁，进行同步代码块方法，进行睡眠。之后第一个线程睡眠时间过后要进行第二个同步代码块的执行，这时sb2的锁握在了第二个线程，而第二个线程在醒来后要获取第二块同步方法的锁时，这时的锁在第一个线程中。两个线程同时在等待对方释放手中的锁，导致了死锁的出现。
5、线程的通信
/** * 生产者 --> 店员(数量最多存放20) --> 消费者 * */ class Clerk { int num; public synchronized void addProduct() { if (num >= 20) { try { wait(); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } } notifyAll(); num++; System.out.println(Thread.currentThread().getName() + ":" + num); } public synchronized void consume() { if (num == 0) { try { wait(); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } } notifyAll(); System.out.println(Thread.currentThread().getName() + ":" + num); num--; } } class Customer implements Runnable { Clerk clerk; public Customer(Clerk clerk) { this.clerk = clerk; } public void run() { while(true) { try { Thread.currentThread().sleep(10); } catch (InterruptedException e) { e.printStackTrace(); } clerk.consume(); } } } class Producer implements Runnable { Clerk clerk; public Producer(Clerk clerk) { this.clerk = clerk; } public void run() { while(true) { try { Thread.currentThread().sleep(10); } catch (InterruptedException e) { e.printStackTrace(); } clerk.addProduct(); } } } public class TestMain { public static void main(String[] args) { Clerk clerk = new Clerk(); Customer c1 = new Customer(clerk); Producer p1 = new Producer(clerk); Thread th2 = new Thread(p1, "生产者"); Thread th1 = new Thread(c1, "消费者"); th2.start(); th1.start(); } }
