黑马程序员——多线程

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

  进程：是一个正在执行中的程序。每一个进程执行中都有一个执行的顺序，该顺序就是一个执行路径或者叫一个控制单元。

  线程：进程中的一个独立的控制单元。线程控制着进程的执行。

  一个进程中至少有一个线程。 JVM 启动的时候就会有java.exe.该进程中的至少一个线程负责java程序中的执行这个线程的代码就在main函数中，称之为主线程。扩展：其实更细节的地方在于jvm启动的线程不止一个。

 自定义一个线程，需要使用到Thread类。创建线程的一种方式是继承Thread类，复写run方法，调用线程的start方法，启动线程，调用run方法。

我们需要知道的是，某一个时刻只有一个程序在运行（多核除外）。多线程的另一个特性是随机性，即cpu执行的程序是随机的，时长也是CPU决定的。

前面要复写run方法，原因是该类定义了一个功能，用于存储线程要运行的代码，这个功能就是run方法。run仅仅是封装了线程要运行的代码，start则是要调用底层资源，实现多线程。

  为了更好的理解进程，需要知道进程的几种状态。

 每一个线程都有自己的名字，系统默认的是从Thread-n 开始的。这里有有两个获取线程对象名字的方法：static Thread currentThread（）获取当前线程对象； getName（）：获取线程名称。设置线程名称：setName或者构造函数。

 创建线程的第二种方法：通过实行Runnable的接口，同样是复写run方法，这样是将要运行的代码放在run方法中，通过Thread类建立线程对象，通过Runnable接口的子类对象作为实际参数传递给Thread类的构造函数，调用Trhead类的start方法开启线程并调用Runable接口子类的run方法。

 两种建立线程的区别：实现的方式在于避免了单继承的局限性，在定义线程的时候，建议使用第二种，实现方式。继承Thread的线程代码放在run类方法中，实现是存放在接口的子类run方法中。

 实现多线程虽然可以提高效率，但是副作用就是安全问题，对共享数据的操作会出现问题。那么，解决的方式就是同步代码块。synchronized（对象）{ 需要被同步的代码  }。需要同步的代码 里面就是 对共享数据的操作步骤。原理：对象如同锁，持有锁就可以执行，没有锁即使有执行权，没有办法运行，因为没有锁。那么，我们可以中的同步必须要有两个或者两个以上的线程。必须多个线程同用一个锁。必须保证只有一个线程在执行。缺点就是效率比较低，消耗资源。

package com.itheima;
class Bank
{
 private int sum;
  Object obj=new Object();
 public  void add(int n)
 {
	synchronized(obj) 	//这个就是同步锁要有对象，我们使用了object类，下面的代码块就是对共享数据进行的操作

{
	 sum+=n;
	 try{
		 Thread.sleep(3);
	 }
	 catch(Exception e)
	 {}
	 System.out.println(sum);
	
	  }			
    }
}
class kk implements Runnable     //实现Runnable的接口
{
  private Bank b=new Bank();
  public void run()
  {
	  for(int x=0;x<3;x++)
	  {
		  b.add(100);
	  }
  }
}
 public class test6 
 {
	 public static void main(String[] args)
	 {
		 kk c=new kk();
		Thread t1=new Thread(c);    //建立线程  

		 Thread t2=new Thread(c);
		t1.start();     //线程的启动
		 t2.start();		 
	 }
}

  我们需要知道的是同步函数使用的锁是this，因为函数需要对象被调用，那么函数需要一个所属引用，需要的真是this。那么，如果是静态的同步函数时，我们知道不能是this的，因为不能定义的原因。静态进内存的时候，没有本类对象的，但是一定有该类对应的字节码文件对象。类.class 该对象的类型是class。静态的同步方法，使用的锁是是该类方法所在的类字节码文件对象。类名.class。

 public static void show()
 { 
	synchronized(类名.class)
	 if(tick>0)
	 {
		 
	 }
 }

   我们需要注意的不能同步中嵌套同步，那样容易形成死锁。

   单例设计模式下的多线程。在懒汉式中，有实例的延迟加载。在多线程访问的时候，有创建多个类的安全遗憾，需要加同步。这样带来的问题是低效，解决的办法是if双判断。正是因为如此的复杂，平时我们需要用的是饿汉式。

  上面是多个线程在对共享的数据操作带来问题时处理方案。我们在对于同一个资源时，当操作动作不一样时，容易带来一些问题，解决的办法包括静态，单例。那么，思路就是我们在创建方法之前，创建共享的数据。

package com.itheima;

 public class test6 
 {
	 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);
		t1.start();
		t2.start();
	 }
 }
 class  Resource 
 {
	 private String name;
	 private int  count=1;
	 private boolean flag=false;
	 public synchronized void set(String name)
	 {
		 if(flag)
		 {
			try{wait();}
			catch(Exception e)
			{}
		}
		 this.name=name+"  "+count++;
		 System.out.println(Thread.currentThread().getName()+" producter "+this.name);
		 flag=true;
		 this.notify(); 
	 }
	 public synchronized void out()
	 {
		 if(!flag)         // 这里的判断使用是为了 两个线程轮流来执行。
		 {
			try{wait();}
			catch(Exception e)
			{}
		}
		 System.out.println(Thread.currentThread().getName()+" cosmer  "+this.name);
	 flag=false;
	 this.notify();     //这里唤醒，当多个线程的时候我们需要使用的是ALL,因为多线程容易出现安全问题
	 }
 }
 
 class Producer implements Runnable
 {
	 private Resource res;
	 Producer(Resource res)
	 {
		 this.res=res;
		 
	 }
	 public void run()
	 {
		 while(true)
		 {
			 res.set("商品");
		 }
	 }
 }
 class Consumer implements Runnable
 {
	 private Resource res;
	 Consumer(Resource res)
	 {
		 this.res=res;
		 
	 }
	 public void run()
	 {
		 while(true)
		 {
			 res.out();
		 }
	 }
 }

private String name;
	 private int  count=1;
	 private boolean flag=false;
	 private Lock lock=new ReentrantLock();
	 private Condition con=lock.newCondition();
	 public  void set(String name) throws InterruptedException
	 {
		 <span style="background-color: rgb(0, 0, 0);"><span style="color:#ffffff;">lock.lock();</span></span>
		 try{
		 while(flag)
		   condition.await();
		 this.name=name+"  "+count++;
		 System.out.println(Thread.currentThread().getName()+" producter "+this.name);
		 flag=true;
		<condition.signal();
		 }
		 final{
	   lock.unlock();
		 }
	 }

     接口lock，是对synchronized的替代，可以理解为手动加锁。支持Condition接口，它将加锁的各个步骤分解。以便于使用。我们需要唤醒使用的signal（）方法。
  下面需要知道停止线程的方法。之前的版本里有stop方法，不再使用了。使用run方法，原理就是控制循环，从而停止线程。当没有指定的方式让冻结的线程恢复到运行状态，这时需要对冻结进行消除，强制让线程恢复到运行状态中来，这样可以通过操作标记来让线程结束。Thread类总提供了interrupt（）；

  守护线程可以理解为后台线程，与前台线程启动运行没差别在结束的时候，只要前台结束，守护线程自动结束。setDaemon() 这个就是设置守护线程，用于设置一个线程依赖于另一个线程时。

  join（）方法：加入线程，争取CPU执行，主线程处于了冻结状态，直到加入的线程结束主线程恢复到运行状态。注意：join的线程执行完，主线程才运行。

  设置优先级：setPriority（int newPriority），t1.setPriority(Thread.MAX_PRIORITY) 设置为最高的优先级，同理可知，MIN，NORM分别为最低，默认。

  yield：表示停止当前线程。Thread.yield（）；减缓线程执行的频率。