进程、线程和多线程

• 进程：正在进行中的程序（直译）。
• 线程：进程中一个负责程序执行的控制单元（执行路径）。
• 多线程：一个进程中可以有多个执行路径，称之为多线程。
  • 好处：解决了多部分代码同时运行的问题。
  • 弊端：线程太多，会导致效率的降低。

创建进程方式

方式一：继承Thread类

• 步骤：
  1. 定义一个类继承Thread类。
  2. 覆盖Thread类中的run方法。
  3. 直接创建Thread的子类对象创建线程。
  4. 调用start方法开启线程并调用线程的任务run方法执行。

构造方法：

• Thread(Runnable target)分配新的 Thread 对象，target为其run 方法被调用的对象。

继承自Object的方法

• void wait( ) / void wait(long timeout) 让线程处于冻结状态，被wait的线程会被存储到线程池中。
• void notify( ) 唤醒线程池中的一个线程（任何一个都有可能）。
• void notifyAll( ) 唤醒线程池中的所有线程。
  注意：该三种方法只能由锁来调用

常用方法

• static Thread currentThread( ) 返回对当前正在执行的线程对象的引用

• long getId( ) 返回该线程的标识符。

• void setName( String name **)**改变线程名称，使之与参数 name 相同。

• String getName( ) 返回该线程的名称。

• void setPriority( int newPriority ) 更改线程的优先级。

• int getPriority( ) 返回线程的优先级。

• Thread.State getState( ) 返回该线程的状态。

  线程状态（6中）： NEW、RUNNABLE、BLOCKED、WAITING、TIMED_WAITING和TERMINATED已

• String toString( ) 返回该线程的字符串表示形式，包括线程名称、优先级和线程组。

• void run( ) 如果该线程是使用独立的 Runnable 运行对象构造的，则调用该 Runnable 对象的 run 方法；否则，该方法不执行任何操作并返回。

• static void sleep( long millis ) 在指定的毫秒数内让当前正在执行的线程休眠（暂停执行）。

  • wait和sleep区别
    1. wait可以指定时间也可以不指定。sleep必须指定时间
    2. 在同步中，对CPU的执行权和锁的处理不同
       • wait：释放执行权，释放锁
       • sleep：释放执行权，不释放锁

• void start( ) 使该线程开始执行；Java 虚拟机调用该线程的 run 方法。

• void join( ) 等待该线程终止（当A线程执行到B线程的.join()方法时，等B线程都执行完，A才会执行）。注：临时加入一个线程可以使用该方法。

• static void yield( ) 暂停当前正在执行的线程对象，并执行其他线程。

• void setDaemon( boolean on ) 将该线程标记为守护线程或用户线程。

方式二：实现 Runnable 接口（常用方式：避免了Java单继承的局限性）

• 步骤：
  1. 定义类实现Runnable接口。
  2. 覆盖接口中的run方法，将线程的任务代码封装到run方法中。
  3. 通过Thread类创建线程对象，并将Runnable接口的子类对象作为Thread类的构造函数的参数进行传递（因为线程的任务都封装在Runnable接口子类对象的run方法中。所以要在线程对象创建时就必须明确要运行的任务）。
  4. 调用线程对象的start方法开启线程。

线程安全问题

产生原因

• 多个线程在操作共享数据
• 操作共享数据的线程代码有多条
  当一个线程在执行操作共享数据的多条代码过程中，其他线程参与了运算，就导致线程安全问题的产生。

解决办法

对多条操作共享数据的语句，只能让一个线程都执行完。在执行过程中，其他线程不可以参与执行。

同步代码块

• 格式：

	synchronized(obj)
	{
		//obj是一个对象，表示锁(监视器锁)
		//持有锁的线程可以在同步中执行，没有持有锁的线程即使获取cpu的执行权，也进不去，因为没有获取锁。
	}

同步方法(函数)

• 格式：在方法上加上synchronized修饰符即可。（一般不直接在run方法上添加） 同步方法的同步监听器其实是 this

	synchronized 返回值类型 方法名（参数列表）
	｛

	｝

• 同步函数和同步代码块的区别

  • 同步函数的锁是固定的this
  • 同步代码块的锁是任意的对象 建议使用同步代码块

• 注意：

  • 如果同步函数和同步代码块都使用this作为锁，就可以实现同步
  • 静态同步函数的锁是该函数所属字节码文件对象，可以getClass方法获取，也可以用当前类名.class表示。

• 死锁： 常见情形为同步的嵌套，当两个线程相互等待对方释放同步监视器时就会发生死锁。一旦出现死锁，程序既不会发生任何异常，也不会出现任何提示。

同步锁

JDK 1.5以后的另一种同步机制，将同步和锁封装成对象

• Lock接口（位于java.util.concurrent.locks包）：替代了同步代码块或者同步函数

  • 子类：ReentrantLock
  • 方法摘要：
    • Condition newCondition() 返回绑定到此 Lock 实例的新 Condition 实例,以调用其方法。
    • void lock( ) 获取锁
    • void unlock( ) 释放锁 ，为了防止异常出现，导致锁无法被关闭，所以锁的关闭动作要放在fianlly中

• Condition接口（位于java.util.concurrent.locks包）：

  • 替代了Object中的wait、notify和notifyAll方法，分别为：await、signal和signalAll方法。

线程间通信

使用时机

多个线程在处理同一资源，但是任务却不同，这时就需要线程间通信。

等待/唤醒机制方法

wait、notify和notifyAll都定义在Object类中，因为这些方法都是监视器（锁）的方法，锁可以是任意的对象，任意的对象调用方式一定在Object类中。

• 生产者消费者示例（生产一个，消费一个）：

	//该示例中，实现了本方只唤醒对方的操作
	import java.util.concurrent.locks.*;

	class ProducerConsumerDemo {
		public static void main(String[] args) {
			Resource r=new Resource();

			//通过已有的锁获取两组监视器，一组监视生产者，一组监视消费者
			Producer pro=new Producer(r);
			Consumer con=new Consumer(r);

			Thread t1=new Thread(pro);
			Thread t2=new Thread(con);
			Thread t3=new Thread(pro);
			Thread t4=new Thread(con);

			t1.start();
			t2.start();
			t3.start();
			t4.start();
		}
	}


	class Resource {
		private String name;
		private int count=1;
		private boolean flag=false;

		private Lock lock=new ReentrantLock();

		private Condition condition_pro =lock.newCondition();
		private Condition condition_con =lock.newCondition();

		public void set(String name)throws InterruptedException {
			//加锁
			lock.lock();
			try {
				while(flag)
					condition_pro.await();	//生产方线程被存储到线程池中

				this.name=name+"..."+count++;
				System.out.println(Thread.currentThread().getName()+".....生产者....."+this.name);
				flag=true;
				condition_con.signal();		//唤醒处于线程池中的消费方线程
			}
			// 使用finally块保证释放锁
			finally{
				lock.unlock();
			}

		}

		public void out()throws InterruptedException {
			//加锁
			lock.lock();
			try {
				while(!flag)
					condition_con.await();	//消费方线程被存储到线程池中

				System.out.println(Thread.currentThread().getName()+"...消费者..."+this.name);
				flag=false;
				condition_pro.signal();		//唤醒处于线程池中的生产方线程
			}
			// 使用finally块保证释放锁
			finally {
				lock.unlock();
			}
		}
	}

	//定义生产者类，实现Runnable接口，覆盖run方法
	class Producer implements Runnable {
		private Resource res;
		Producer(Resource res) {
			this.res=res;
		}
		public void run(){
			while (true) {
				try {
					res.set("+商品+");
				}
				catch (InterruptedException e) {
				}
			}
		}

	}

	//定义消费者类，实现Runnable接口，覆盖run方法
	class Consumer implements Runnable {
		private Resource res;
		Consumer(Resource res) {
			this.res=res;
		}

		public void run() {
			while (true) {
				try {
					res.out();
				}
				catch (InterruptedException e) {
				}
			}
		}
	}

停止线程

• 思路：
  • 任务中通常都有循环结构，只要控制循环就可以结束任务
  • 控制循环通常用定义标记来完成
  • 如果线程处于冻结状态，无法读取标记，可以使用interrupt()方法将线程从冻结状态强行恢复到运行状态，让线程具备CPU执行权，该动作会发生InterruptedException，需要处理