黑马程序员_多线程

　------- android培训、java培训、期待与您交流！ ----------

        我们使用计算机时，计算机上有很多的程序在执行，每个程序都被称之为一个进程，但是进程在执行的过程中，往往我们会看到一个程序同时做着多件不同的事情，其实并不是这样子的，这就是利用了多线程，每个事情就是一个线程，程序在执行过程中不断的来回切换正在执行线程，只不过CPU的执行速度太快以至于我们认为程序在同时做着不同的事情。现在我们就来看看如何使用java开发多线程。

        java创建多线程有两种方式。

        java中提供了一类一接口两种方式创建多线程，类是Thread类，接口是Runnable接口

        方式一：通过查找API发现Thread类是一个抽象类，我们要创建抽象类的实例实际上需要的是抽象类的子类对象。

        对象的问题解决了以后，我们又该如何启动线程，我们要用多线程做的事情又该怎么写呢？

        其实在Thread类中提供了两个方法一个是run()方法，一个是start()方法，根据API中的介绍我们启动线程调用的是start()方法，并且start()方法的底层其实也是调用run()方法。我们需要线程做得事情的代码也是放在了run()方法中。

         首先创建Thread类的子类MyThread类

         其次重写run()方法

         最后在main方法中创建子类对象并开启线程

        

package cn.itheima01;

public class MyThread extends Thread{
	@Override
	public void run() {
		for(int x = 0; x < 100; x++){
			System.out.println(this.getName()+"--"+x);
		}
	
	}
}

package cn.itheima01;

public class MyThreadDemo {

	public static void main(String[] args) {

		MyThread mt1 = new MyThread();
		MyThread mt2 = new MyThread();
		
		mt1.start();
		mt2.start();
		
	}

}

        这样一个简单的多线程的例子就写完了。

        方式二：通过接口去实现多线程，java提供了Runnable接口，只需要提供Runnable接口的子类对象同样可以完成上述的操作，下面我们就来看看怎么做的。

       

package cn.itheima02;

public class MyRunnable implements Runnable{

	@Override
	public void run() {

		for(int x = 0; x < 100; x++){
			System.out.println(Thread.currentThread().getName()+","+x);
		}
		
	}

}

package cn.itheima02;

public class MyThreadDemo {

	public static void main(String[] args) {

		MyRunnable mr1 = new MyRunnable();
		Thread th1 = new Thread(mr1);
		Thread th2 = new Thread(mr1);
		
		th1.start();
		th2.start();
			
	}

}

       以上两种方法，就是使用java实现多线程的方法，其实以上两种放发我们发现了还有很大的缺陷，就是数据不能共享。

       那么java就提供了一个机制，同步机制。同步进制就是对线程加锁，只有锁对象是同一个时，程序才会往下执行

       下面我们来看看java是怎么利用锁机制来同步的。

       java提供了关键字synchronized，

       需求：卖票，假设现在有100张票，有两个窗口同时进行售票，用程序实现

       分析：两个窗口同时进行售票的话，就代表了有两个线程。数据是100

      

package cn.itheima10;

public class SellTicket implements Runnable {
	private int tickets = 100;
	private Object obj = new Object();

	@Override
	public void run() {

		while (true) {
			synchronized (obj) {
				if (tickets > 0) {
					try {
						Thread.sleep(100);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}

					System.out.println(Thread.currentThread().getName()
							+ "正在出售第" + (tickets--) + "张电影票");
				}
			}
		}

	}
}

       上面类中用到了一个sleep()方法，sleep()方法用于让线程休眠，100所指的是100毫秒。

package cn.itheima10;

public class ThreadTicketDemo {

	public static void main(String[] args) {

		SellTicket st = new SellTicket();
		
		Thread t1 = new Thread(st,"售票窗口1");
		Thread t2 = new Thread(st,"售票窗口2");
		Thread t3 = new Thread(st,"售票窗口3");
		
		t1.start();
		t2.start();
		t3.start();
		
	}

}

其实上述方法使用的是同步代码块去实现，我们可以将同步代码块换成同步方法去实现，不过从上面的例子我们发现，用的是Object对象锁，那么同步方法的锁又是什么呢？

SellTicket类中的售票部分改成普通方法和静态

package cn.itheima11;

public class SellTicket implements Runnable {
	private static int tickets = 100;
	private Object obj = new Object();
	private int x = 0;
	@Override
	public void run() {

		while (true) {
			if(x%2==0){
				synchronized (SellTicket.class) {
					if (tickets > 0) {
						try {
							Thread.sleep(100);
						} catch (InterruptedException e) {
							e.printStackTrace();
						}

						System.out.println(Thread.currentThread().getName()
								+ "正在出售第" + (tickets--) + "张电影票");
					}
				}
			}else{
				sell();
			}
			x++;
		}

	}
	private synchronized void sell() {
		
			if (tickets > 0) {
				try {
					Thread.sleep(100);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}

				System.out.println(Thread.currentThread().getName()
						+ "正在出售第" + (tickets--) + "张电影票");
			}
		
	}
}

package cn.itheima11;

public class SellTicket implements Runnable {
	private static int tickets = 100;
	private Object obj = new Object();
	private int x = 0;
	@Override
	public void run() {

		while (true) {
			if(x%2==0){
				synchronized (SellTicket.class) {
					if (tickets > 0) {
						try {
							Thread.sleep(100);
						} catch (InterruptedException e) {
							e.printStackTrace();
						}

						System.out.println(Thread.currentThread().getName()
								+ "正在出售第" + (tickets--) + "张电影票");
					}
				}
			}else{
				sell();
			}
			x++;
		}

	}
	private static synchronized void sell() {
		
			if (tickets > 0) {
				try {
					Thread.sleep(100);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}

				System.out.println(Thread.currentThread().getName()
						+ "正在出售第" + (tickets--) + "张电影票");
			}
		
	}
}

       改成以上方法实现，效果一样，但是同步方法和静态同步方法的的锁对象是什么呢？

        其实同步方法的锁对象是this

       而静态同步方法的锁对象是当前类对象的字节码文件