多线程编程

一、多线程的基本概念

线程是进程的一个执行单位，又称轻量进进程，他和进程一样拥有独立的执行控制，由操作系统负责调度。

而多线程是这样一种机制：他允许在程序中并发执行多个指令流，每个指令流都称为一个线程，多线程机制下的线程彼此间互相独立，比较容易共享数据，通过并发执行的方式来提高程序的效率和性能。

二、进程和线程的区别

1）线程的划分尺度小于进程，线程隶属于某个进程。

2）进程是程序的一种动态形式，是CPU、内存等资源占用的基本单位，而线程是不能独立的占有这些资源的。

3）进程之间的互相独立，通信比较困难，而线程之间共享一块内存区域，通信比较方便。

4）进程在执行过程中，包含比较固定的入口、执行顺序和出口，而线程的这些过程会被应用程序所控制。

三、多线程编程

3.1、将一个类成为线程类

让一个类成为线程类的方式有两种：一个是实现java.lang.Runnable接口，另一个是继承自java.lang.Thread类

3.2、Runnable接口和Thread类有何区别

1）线程类继承自Thread则不能继承其他类，而Runnable接口可以。

2）线程类继承自Thread相对Runnable来说，使用线程的方法更方便一些。

3）实现Runnable接口的线程类的多个线程，可以更方便的访问同一变量，而Thread类则需要内部类来进行替代。

 

3.3、启动一个线程

继承自Thread类的线程类，可以通过new关键字创建一个线程对象以后，执行start()方法开始一个线程，而实现了Runnable接口的线程类，需要用它的对象实例，作为Thread类构造方法的参数，创建一个Thread对象，然后调用start()方法开始一个线程。

3.4、sychronized来让线程同步

sychronized关键字代表要为某一段代码加上一个同步锁，这样的锁是绑定在某一个对象上面的，如果是同步代码块，需要为该sychronized关键字提供一个对象的引用；如果是同步方法，只需要加一个sychronized关键字的修饰。

sychronized为某段代码加上锁以后，某个线程进入该段代码之前，首先需要检查该锁是否被占用，如果没有被占用则继续执行；如果已经被占用，则需要等到该锁被释放以后才能继续执行。其中，线程执行完该段代码就是释放锁的标志。

 

//运行下段代码之后发现线程之间没有等谁执行完以后再执行，而是交织着执行的
class MyThread extends Thread 
{
	public static int index;
	public void run()
	{
		for(int i=0;i<100;i++)
		{
			System.out.println(getName()+" :"+index++);
		}
	}
}
public class SyncTest
{
	public static void main(String args [])
	{
		new MyThread().start();
		new MyThread().start();
		new MyThread().start();
	}
}

 

代码改进：

//运行下段代码之后，发现刚才的问题解决了，线程逐个执行完成
class MyThread extends Thread 
{
	public static int index;
	public static Object obj=new Object();//用任意一个对象来加锁
	public void run()
	{
		synchronized(obj)//为冲突加上同步代码块
		{
			for(int i=0;i<100;i++)
			{
				System.out.println(getName()+" :"+index++);
			}
		}
	}
}
public class SyncTest
{
	public static void main(String args [])
	{
		new MyThread().start();
		new MyThread().start();
		new MyThread().start();
	}
}

 

 

下面编写一个生产者跟消费者模型的多线程例子程序

public class Store 
{
	private final int MAX_SIZE;//仓库最大容量
	private int count;//当前的货物数量
	public Store(int n)
	{
		MAX_SIZE=n;
		count=0;
	}
	public synchronized void add()
	{
		while(count>=MAX_SIZE)
		{
			System.out.println("已经满了");
			try
			{
				this.wait();//如果满了，就放入等待池	
			}
			catch (InterruptedException e)
			{
				e.printStackTrace();
			}
		}
		count++;
		System.out.println(Thread.currentThread().toString()+" put "+count);
		this.notifyAll();//通知所有消费者线程可拿
	}
	public synchronized void remove()
	{
		while(count<=0)
		{
			System.out.println("空了");
			try
			{
				this.wait();
			}
			catch (InterruptedException e)
			{
				e.printStackTrace();
			}
		}
		System.out.println(Thread.currentThread().toString()+" get "+count);
		count--;
		this.notify();
	}
	public static void main(String [] args) 
	{
		Store s=new Store(5);
		//创建两个生产者和两个消费者
		Thread pro=new Producer(s);
		Thread con=new Consumer(s);
		Thread pro2=new Producer(s);
		Thread con2=new Consumer(s);
		pro.setName("producer");
		con.setName("consumer");
		pro2.setName("producer2");
		con2.setName("consumer2");
		//启动多线程
		pro.start();
		con.start();
		pro2.start();
		con2.start();
	}
}
class Producer extends Thread
{
	private Store s;
	public Producer(Store s)
	{
		this.s=s;
	}
	public void run()
	{
		s.add();
		try
		{
			Thread.sleep(1000);//休息一秒
		}
		catch (InterruptedException e)
		{
			e.printStackTrace();
		}
	}
}
class Consumer extends Thread
{
	private Store s;
	public Consumer(Store s)
	{
		this.s=s;
	}
	public void run()
	{
		s.remove();
		try
		{
			Thread.sleep(1500);//休息1.5秒
		}
		catch (InterruptedException e)
		{
			e.printStackTrace();
		}
	}
}