编程开发之--java多线程学习总结（1）问题引入与概念叙述
1、经典问题，火车站售票，公共票源箱，多个窗口同时取箱中车票销售
package com.lfy.ThreadsSynchronize; /** * 解决办法分析：即我们不能同时让超过两个以上的线程进入到 if(num>0)的代码块中 * 1、使用 同步代码块 2、使用 同步方法 3、使用 锁机制 */ public class TicketSell1 extends Thread{ //定义一共有 50 张票，注意声明为 static,表示几个窗口共享 private static int num = 50; //调用父类构造方法，给线程命名 public TicketSell1(String string) { super(string); } @Override public void run() { //票分 50 次卖完 for(int i = 0 ; i < 50 ;i ++){ if(num > 0){ try { Thread.sleep(10);//模拟卖票需要一定的时间 } catch (InterruptedException e) { // 由于父类的 run()方法没有抛出任何异常，根据继承的原则，子类抛出的异常不能大于父类， 故我们这里也不能抛出异常 e.printStackTrace(); } System.out.println(Thread.currentThread().getName()+"卖出一张票，剩余"+(--num)+"张"); } } } }
2、对于解决办法，java中专门提供了synchronized关键字处理多线程同步问题，有了synchronized关键字，多线程程序的运行结果将变得可以控制。synchronized关键字用于保护共享数据。synchronized实现同步的机制：synchronized依靠"锁"机制进行多线程同步，"锁"有2种，一种是对象锁，一种是类锁。synchronized关键字修饰普通方法时，获得的锁是对象锁，也就是this。而修饰静态方法时，锁是类锁，也就是类名.class。
阻塞：A、B线程同时运行，由于锁的控制，某时刻A线程还能继续执行，B线程被挂起等待了，就说B线程被阻塞了。
（1）对象锁，使用synchronized修饰多个普通方法，当不同线程调用同一个对象的不同被synchronized修饰过的方法时，第一个调用被synchronized修饰过的方法的线程会得到对象锁，其他线程处于阻塞状态，直至第一个得到锁的线程退出被synchronized修饰过的方法。举个例子：
package lfy; public class TestSynchronized { public synchronized void method1() throws InterruptedException { System.out.println("method1 begin at:" + System.currentTimeMillis()); System.out.println("method1 begin to sleep 5s"); Thread.sleep(5000); System.out.println("method1 end at:" + System.currentTimeMillis()); } public synchronized void method2() throws InterruptedException { for(int i=0;i<5;i++) { System.out.println("method2 running"); Thread.sleep(200); } } static TestSynchronized instance = new TestSynchronized(); public static void main(String[] args) { Thread thread1 = new Thread(new Runnable() { @Override public void run() { try { instance.method1(); } catch (InterruptedException e) { e.printStackTrace(); } for(int i=1; i<4; i++) { try { Thread.sleep(200); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("Thread1 still alive"); } System.out.println("Thread1 over"); } }); Thread thread2 = new Thread(new Runnable() { @Override public void run() { try { instance.method2(); System.out.println("Thread2 over"); } catch (InterruptedException e) { e.printStackTrace(); } } }); thread1.start(); thread2.start(); } }
运行结果：
解释：创建了一个对象实例instance，创建两个线程Thread1、Thread2，它们分别调用instance的mothod1、mothod2方法，由于线程1先启动并先访问到被synchronized修饰的mothod1，此时instance对mothod2上锁，线程2此时只能等待mothod2的锁被释放，才能执行mothod2方法。这就是对象锁机制。
（2）类锁，对所有对象调用被synchronized修饰的static方法进行锁定，没有被synchronized修饰的static方法不会被上锁。
package lfy; public class TestSynchronized { public synchronized static void method1() throws InterruptedException { System.out.println("method1 begin at:" + System.currentTimeMillis()); System.out.println("method1 begin to sleep 5s"); Thread.sleep(5000); System.out.println("method1 end at:" + System.currentTimeMillis()); } public synchronized static void method2() throws InterruptedException { for(int i=0;i<5;i++) { System.out.println("method2 running"); Thread.sleep(200); } } /** * 没有static、synchronized修饰的普通方法 * @throws InterruptedException */ public void method3() throws InterruptedException { System.out.println("method3 running"); Thread.sleep(200); } /** * 只有synchronized修饰的普通方法 * @throws InterruptedException */ public synchronized void method4() throws InterruptedException { System.out.println("method4 running"); Thread.sleep(200); } static TestSynchronized instance1 = new TestSynchronized(); static TestSynchronized instance2 = new TestSynchronized(); static TestSynchronized instance3 = new TestSynchronized(); static TestSynchronized instance4 = new TestSynchronized(); public static void main(String[] args) { Thread thread1 = new Thread(new Runnable() { @Override public void run() { try { instance1.method1();
//TestSynchronized.mothod1(); } catch (InterruptedException e) { e.printStackTrace(); } for(int i=1; i<4; i++) { try { Thread.sleep(200); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("Thread1 still alive"); } System.out.println("Thread1 over"); } }); Thread thread2 = new Thread(new Runnable() { @Override public void run() { try { instance2.method2();
//TestSynchronized.mothod2(); System.out.println("Thread2 over"); } catch (InterruptedException e) { e.printStackTrace(); } } }); Thread thread3 = new Thread(new Runnable() { @Override public void run() { try { instance3.method3(); System.out.println("method3 over"); Thread.sleep(10000); System.out.println("Thread3 still alive"); System.out.println("Thread3 now to over"); } catch (InterruptedException e) { e.printStackTrace(); } } }); Thread thread4 = new Thread(new Runnable() { @Override public void run() { try { instance4.method4(); System.out.println("method4 over"); Thread.sleep(10000); System.out.println("Thread4 still alive"); System.out.println("Thread4 now to over"); } catch (InterruptedException e) { e.printStackTrace(); } } }); thread1.start(); thread2.start(); thread3.start(); thread4.start(); } }
运行结果：
