java多线程

多线程的实现

可以通过继承Tread类和实现Runnable接口来实现多线程，通过卖票实现多线程代码如下:

package Thread;
// 继承Thread类
class ConductorThread extends Thread{
	private int ticketNum = 5;
	@Override
	public void run() {
		for(int i=5;i>0;i--) {
			if(this.ticketNum>0) {
				this.ticketNum--;
				System.out.println(Thread.currentThread().getName() + "卖了1张票剩余" + this.ticketNum+ "张票");
			}
		}
	}
}

//实现Runnable接口
class ConductorRunnable implements Runnable{
	private int ticketNum = 5;
	@Override
	public void run() {
		for(int i=5;i>0;i--) {
			if(this.ticketNum>0) {
				this.ticketNum--;
				System.out.println(Thread.currentThread().getName()+"卖了1张票剩余"+this.ticketNum+"张票");
			}
		}
	}
}

public class RailwayStation {
	public static void main(String args[]) {
		// 创建实例对象
		ConductorThread conductorThread = new ConductorThread();
		ConductorRunnable conductorRunnable = new ConductorRunnable();
		
		//为实例对象创建两个售票员线程
		Thread conductor1 = new Thread(conductorThread,"售票员1") ;
		Thread conductor2 = new Thread(conductorThread,"售票员2") ;

		Thread conductor3 = new Thread(conductorRunnable,"售票员3");
		Thread conductor4 = new Thread(conductorRunnable,"售票员4");
		// 启动线程
		conductor1.start();
		conductor2.start();	
		conductor3.start();
		conductor4.start();
	}
}

运行结果：

售票员1卖了1张票剩余4张票
售票员1卖了1张票剩余2张票
售票员1卖了1张票剩余1张票
售票员1卖了1张票剩余0张票
售票员2卖了1张票剩余3张票
售票员4卖了1张票剩余3张票
售票员3卖了1张票剩余3张票
售票员4卖了1张票剩余2张票
售票员3卖了1张票剩余1张票
售票员4卖了1张票剩余0张票

如果创建了两个实例对象，则会卖两倍的票数，这是因为普通成员变量的ticketNum会被初始化两次。

Thread和Runnable的区别

阅读源码

public interface Runnable {
    /**
     * When an object implementing interface <code>Runnable</code> is used
     * to create a thread, starting the thread causes the object's
     * <code>run</code> method to be called in that separately executing
     * thread.
     * <p>
     * The general contract of the method <code>run</code> is that it may
     * take any action whatsoever.
     *
     * @see     java.lang.Thread#run()
     */
    public abstract void run();
}

public
class Thread implements Runnable {
    /* Make sure registerNatives is the first thing <clinit> does. */
    private static native void registerNatives();
    static {
        registerNatives();
    }

    private volatile String name;
    private int            priority;
    private Thread         threadQ;
    private long           eetop;

    /* Whether or not to single_step this thread. */
    private boolean     single_step;
    ......
}

• Thread类实现了Runnable接口，当一个类A继承了类B，类B没有继承Thread，由于java的单继承性，类B要想实现多线程，则不能继承Thread类，只能实现Runnable接口。
• Runnable可以看做一个一个具体的task，在task下有多个线程共同来执行这个task，不同线程之间的资源是可以共享的。Thread作为线程的载体，不同Thread对象之间不可以进行资源共享。

线程的状态

• 新建状态

new出新对象，调用start方法，线程进入就绪状态，已经启动的线程不能再次调用start方法

• 就绪状态

具备的运行条件，但是没有分到CPU，等待系统为其分配CPU

• 运行状态

运行状态的线程有可能变为阻塞状态
注： 当发生如下情况是，线程会从运行状态变为阻塞状态：

 ①线程调用sleep方法主动放弃所占用的系统资源
 ②线程调用一个阻塞式IO方法，在该方法返回之前，该线程被阻塞
 ③线程试图获得一个同步监视器，但更改同步监视器正被其他线程所持有
 ④线程在等待某个通知（notify）
 ⑤程序调用了线程的suspend方法将线程挂起。不过该方法容易导致死锁，所以程序应该尽量避免使用该方法。

• 阻塞状态

线程执行了sleep方法或者等待I/O设备

• 死亡状态

线程执行完毕或者强制终止

线程同步

在上面的卖票例子中，可能会出现不同的售票员卖同一张票的现象，导致最后剩余票数为负数，显然是不符合实际的，为了使卖票结果最后的剩余值为0，应该使用线程同步方法，来避免这种情况的发生。

class ConductorRunnable implements Runnable{
	private int ticketNum = 5;
	@Override
	public void run() {
		while(this.ticketNum>0) {
			try {
				Thread.sleep(10);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			this.ticketNum--;
			System.out.println(Thread.currentThread().getName() + "卖了1张票剩余" + this.ticketNum+ "张票");
		}
	}
}
public class RailwayStation {
	@Test
	public void test1() {
		// 局部变量创建一个实例对象  实现多线程
		ConductorRunnable conductorRunnable = new ConductorRunnable();

		Thread conductor3 = new Thread(conductorRunnable,"售票员3");
		Thread conductor4 = new Thread(conductorRunnable,"售票员4");
		// 启动线程
		conductor3.start();
		conductor4.start();
	}
        public static void main(String args[]) {
		RailwayStation rw = new RailwayStation();
		rw.test1();
	}

运行结果：

售票员3卖了1张票剩余4张票
售票员4卖了1张票剩余3张票
售票员3卖了1张票剩余2张票
售票员4卖了1张票剩余1张票
售票员3卖了1张票剩余0张票
售票员4卖了1张票剩余-1张票

线程同步的几种方法 ：

• 同步方法

在方法前加关键字synchronized，代码入下：

class ConductorRunnable implements Runnable{
	private int ticketNum = 5;
	@Override
	public synchronized void run() {
		while(this.ticketNum>0) {
			try {
				Thread.sleep(10);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			this.ticketNum--;
			System.out.println(Thread.currentThread().getName() + "卖了1张票剩余" + this.ticketNum+ "张票");
		}
	}
}

运行结果入下：

售票员3卖了1张票剩余4张票
售票员3卖了1张票剩余3张票
售票员3卖了1张票剩余2张票
售票员3卖了1张票剩余1张票
售票员3卖了1张票剩余0张票

在java中每一个对象都有一个内置锁，synchronized关键字修饰方法，内置锁会保护整个方法，线程要想执行该方法，必须先获取该方法的内置锁。当一个线程在执行该方法时，另外一个线程就无法获得该该方法的内置锁，会处于block状态，直到前一个方法执行结束，释放内置锁。

• 同步代码块

除了使用synchronized修饰整个方法外，还可以用synchronized来修饰关键代码，来达到同步的目的。代码入下：

class ConductorRunnable implements Runnable{
	private int ticketNum = 5;
	@Override
	public void run() {
		synchronized(this) {
			while(this.ticketNum>0) {
				try {
					Thread.sleep(10);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				this.ticketNum--;
				System.out.println(Thread.currentThread().getName() + "卖了1张票剩余" + this.ticketNum+ "张票");
			}
		}	
	}
}

被synchronized修饰的代码块会被加上内置锁，从而达到同步的目的。

• 使用特殊域变量(volatile)实现线程同步
  可以将线程操作的变量前面加volaile修饰，给变量加入内置锁，代码如下：

class ConductorRunnable implements Runnable{
	private volatile int ticketNum = 5;
	@Override
	public void run() {
		while(this.ticketNum>0) {
			try {
				this.ticketNum--;
				Thread.sleep(10);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName() + "卖了1张票剩余" + this.ticketNum+ "张票");
		}	
	}
}

运行结果：

售票员3卖了1张票剩余3张票
售票员4卖了1张票剩余3张票
售票员4卖了1张票剩余1张票
售票员3卖了1张票剩余1张票
售票员4卖了1张票剩余0张票

1.volatile关键字为域变量的访问提供了一种免锁机制；
2.使用volatile修饰域相当于告诉虚拟机该域可能会被其他线程更新；
3.因此每次使用该域就要重新计算，而不是使用寄存器中的值；
4.多线程的内存模型为主存和线程栈，在处理数据时，线程会把值从主存load到本地栈，完成操作后再save回去(volatile关键词的作用：每次针对该变量的操作都激发一次load and save)。
5.volatile不会提供任何原子操作，它也不能用来修饰final类型的变量。

• 使用重入锁（Lock）实现线程同步

代码入下：

class ConductorRunnable implements Runnable{
	private int ticketNum = 5;
	private Lock lock = new ReentrantLock(); // 声明一个锁
	@Override
	public void run() {
		while(this.ticketNum>0) {
			lock.lock();
			try {
				this.ticketNum--;
				Thread.sleep(10);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName() + "卖了1张票剩余" + this.ticketNum+ "张票");
		}	
	}
}

执行结果如下：

售票员3卖了1张票剩余4张票
售票员3卖了1张票剩余3张票
售票员3卖了1张票剩余2张票
售票员3卖了1张票剩余1张票
售票员3卖了1张票剩余0张票

悲观锁和乐观锁

• 悲观锁

对世界充满了绝望，觉得人和人都会修改数据，每次拿到数据后，都会上锁，避免其他线程更改数据，直到执行完毕释放资源

• 乐观锁

乐观主义者，觉得任何人都不会修改数据，但是在更新的时候会判断一下在此期间别人有没有去更新这个数据，可以使用版本号等机制。乐观锁适用于多读的应用类型，这样可以提高吞吐量

线程通信

• 借助于Object类的wait()、notify()和notifyAll()实现通信
• 使用Condition控制线程通信