★带互斥的共享栈
多线程互斥共享“栈”资源
package thread.stack; public class MyStack { private int idx=0; private char[] data = new char[6]; //本例虽然采用的是两种不同的同步方式，但由于对象锁都是this对象，因此push和pop方法是互斥的 public void push(char c){ synchronized (this) { data[idx] = c; System.out.println("push:" + c); idx++; } } public synchronized char pop(){ idx--; char ch = data[idx]; System.out.println("pop:"+ch); return ch; } }
package thread.stack; public class PushThread extends Thread { private MyStack stack=null; public PushThread(MyStack stack) { this.stack = stack; } @Override public void run() { for(int i=97;i<103;i++){ stack.push((char)i); } } }
package thread.stack; public class PopThread extends Thread { private MyStack stack=null; public PopThread(MyStack stack) { this.stack = stack; } @Override public void run() { for(int i=97;i<103;i++){ stack.pop(); } } }
main方法：
package thread.stack; public class Client { public static void main(String[] args) { MyStack stack = new MyStack(); PushThread t1 = new PushThread(stack); PopThread t2 = new PopThread(stack); t1.start(); t2.start(); } }
多线程调度与控制1
★ Java的多线程是抢占式的运行方式。
★ setPriority()
这个优先级的设置只是相对调度。。。
★ sleep()方法
Thread类的sleep()方法对当前线程操作，是静态方法。sleep()的参数指定以毫秒为单位的线程休眠时间。除非因为中断而提早恢复执行，否则线程不会在这段时间之前恢复执行。
★ interrupt()方法
一个线程可以调用另外一个线程的interrupt()方法，这将向暂停的线程发出一个InterruptedException。变相起到唤醒暂停线程的功能。Thread类的方法interrupt()，是一种强制唤醒的技术。
前面3中方法的代码解释：
package thread.schedule.v1; public class Schedule { public static void main(String[] args) { Thread t1 = new MyRunner(); Thread t2 = new MyRunner(); //采用优先级进行相对调度,相比优先级高的抢占资源的概率要高一些 //t1.setPriority(9); //t2.setPriority(3); t1.start(); t2.start(); try { Thread.sleep(2000); //如果没有被唤醒，则需要10s才能有输出的。现在只需要2s t1.interrupt();//强制唤醒t1线程 } catch (InterruptedException e) { e.printStackTrace(); } } }
package thread.schedule.v1; public class MyRunner extends Thread{ private static Object obj=new Object(); @Override public void run() { synchronized (obj) { try { Thread.sleep(10000); } catch (InterruptedException e) { System.out.println(this.getName()+"已经被唤醒!"); } for (int i = 1; i < 101; i++) { System.out.println(Thread.currentThread().getName() + "--No.--" + i); } } } }
★ yield()方法
用来使具有相同优先级的线程获得执行的机会。如果具有相同优先级的其它线程是可运行的，yield()将把线程放到可运行池中并使另一个线程运行。如果没有相同优先级的可运行线程，则什么都不做。
注意，执行一次yield()方法，该线程只是放弃当前这一次机会，然后又会重新和其它线程一起抢占CPU，很可能又比其它线程先抢到。
★ join()方法
调用某线程的该方法，将当前线程与该线程“合并”，即等待该线程结束，再恢复当前线程的运行。它可以实现线程合并的功能，经常用于线程的绝对调度。
简单的说，就是把线程运行的代码全部搬到运行join()方法的这个地方来！
这就是绝对调度了。这一个线程没有运行完，是不可运行后面的语句的！
package thread.schedule.v2; public class Schedule { public static void main(String[] args) { Thread t1 = new MyRunner("t1"); Thread t2 = new MyRunner("t2"); t1.setPriority(5); t2.setPriority(5); t1.start(); try { t1.join(); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("main......"); t2.start(); } }
package thread.schedule.v2; public class MyRunner extends Thread{ private static Object obj=new Object(); private String threadName=null; public MyRunner(String threadName){ this.threadName = threadName; } @Override public void run() { System.out.println(":::::"+threadName); int num=0; while(threadName.equals("t1") && num<50){//放弃50次机会 Thread.yield();//不释放对象锁 num++; } for (int i = 1; i < 101; i++) { System.out.println(threadName + "--No.--" + i); } } }
知识小结：
★ wait()方法
当前线程进入对象的wait pool。
★notify()/notifyAll()方法
唤醒对象的wait pool中的一个/所有等待线程。
★suspend()、resume()和stop()这几个方法现在已经不提倡使用。
★创建线程和启动线程并不相同
在一个线程对新线程的Thread对象调用start()方法之前，这个线程并没有真正开始执行。Thread对象在其线程真正启动之前就已经存在了，而且其线程退出之后仍然存在。因此，仍可以控制或获取关于已创建的线程的信息，即使线程还没有启动或已经完成了。
★结束线程
线程会以以下三种方式之一结束：
1）线程到达其run()方法的末尾，推荐这种方法，自然结束。
2）线程抛出一个未捕获到的Exception或Error。
3）另一个线程调用一个弃用的stop()方法。
★守护程序线程（简称守护线程）
我们提到过当Java程序的所有线程都完成时，该程序就退出，但这并不完全正确，因为程序中还隐藏的系统线程。
随着程序的启动而启动，在运行期间一直捕捉符合它条件的处理，这样的线程就是守护线程。
★ synchronized必须锁的是对象，基本数据类型的变量不能当作对象锁。
★ 要保证多线程使用的是同一个互斥锁（对象锁），才能进行同步。
