java多线程

一、 创建和启动线程方式：

//（1）、创建Thread类的子类对象，子类中重写run方法

         public class TestThread{
       public static void main(String[]  args){
             MyThread t = new MyThread();
             t.start();
       }
}

          class MyThread extends Thread{
               public void run( ){
                     //代码
                  }
          }
          
        也可以使用匿名内部类(本质：一个继承了类或实现了接口的子类对象)
        public class TestThread{
            public static void main(String[]  args){
           Thread t = new Thread( ){
                 public void run( ){
                       //代码
                      }         
              }；
       }
      //启动线程
        t.start();

   }
 // (2)、创建Thread类 对象，在构造器中传Runnable接口的实现类，实现类中重写run( )方法
             public  class TestThread{
                 public static void main(String[]  args){
                  //创建接口实现类对象
                   MyThread r = new MyThread( );
                     Thread t = new Thread( r);
                       t.start( );
              }
           }
          class    MyThread implements Runnable{
               public void run(){
                           //代码
          }
    }      
          //可以使用匿名内部类
        public  class TestThread{

        public static void main(String[]  args){
            Thread t = new Thread( new Runnable( ){
            public void run( ){
              //代码       
           }   
        });
      }
        }

//(3)实现 Callable<返回值类型>)接口，重新call()方法，执行体在call()方法中，该方法有返回值

 
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.FutureTask;
import java.util.concurrent.RunnableFuture;
 
/**
 * 方式4:实现Callable<T> 接口
 * 含返回值且可抛出异常的线程创建启动方式
 * @author fatah
 */
public class MyThread implements Callable<String>{
 
	public String call() throws Exception {
		System.out.println("正在执行新建线程任务");
		Thread.sleep(2000);
		return "新建线程睡了2s后返回执行结果";

}

常用的创建线程的方式有以上三种，这两种具体使用起来是有一些差别的：

//继承Thread类和实现Runnable接口的区别
第一个继承Thread类来实现多线程，其实是相当于拿出三件事即三个卖早餐10份的任务分别分给三个窗口， 他们各做各的事各卖各的早餐各完成各的任务，因为MyThread继承Thread类，所以在newMyThread的时候,创建三个对象的同时创建了三个线程；

实现Runnable的， 相当于是拿出一个卖早餐10份的任务给三个人去共同完成， newMyThread相当于创建一个任务，然后实例化三个Thread，创建三个线程即安排三个窗口去执行。
前两种创建线程的方式，执行方法中无返回值；第三种有返回值。

关于执行start()方法和run()方法

（1）、用start方法来启动线程，真正实现了多线程运行，这时无需等待run方法体代码执行完毕而直接继续执行下面的代码。
通过调用Thread类的 start()方法来启动一个线程，这时此线程处于就绪（可运行）状态，并没有运行，一旦得到cpu时间片，
就开始执行run()方法，这里方法 run()称为线程体，它包含了要执行的这个线程的内容，Run方法运行结束，此线程随即终止。
2）、run()方法只是类的一个普通方法而已，如果直接调用Run方法，程序中依然只有主线程这一个线程，其程序执行路径还是只有一条，还是要顺序执行，还是要等待run方法体执行完毕后才可继续执行下面的代码，这样就没有达到写线程的目的。

调用start方法方可启动线程，而run方法只是thread的一个普通方法调用，还是在主线程里执行

二、多线程的一些常用方法

1、关于线程休眠：线程类的静态方法：sleep(long millis )
sleep( )方法：使用sleep方法之后，线程由运行状态进入阻塞状态，只有当睡眠的时间结束，才会重新进入到就绪状态，而就绪状态进入到运行状态是由系统控制的，我们不可能精准的去干涉它，所以如果调用Thread.sleep(1000)使得线程睡眠1秒，可能结果会大于1秒。

2、静态方法，yield
yield( ) 方法：该方法和sleep方法类似，也是Thread类提供的一个静态方法，可以让正在执行的线程暂停，但是不会进入阻塞状态，而是直接进入就绪状态。相当于只是将当前线程暂停一下，然后重新进入就绪的线程池中，让线程调度器重新调度一次。也会出现某个线程调用yield方法后暂停，但之后调度器又将其调度出来重新进入到运行状态。
sleep和yield的区别：
　　　　①、sleep方法声明抛出InterruptedException，调用该方法需要捕获该异常。yield没有声明异常，也无需捕获。

②、sleep方法暂停当前线程后，会进入阻塞状态，只有当睡眠时间到了，才会转入就绪状态。而yield方法调用后 ，是直接进入就绪状态
　　　　
3、join方法：非静态方法
把指定的线程加入到当前线程，原本两个线程可以并发执行，join之后变成了两个线程顺序执行。
比如在线程B中调用了线程A的Join()方法，直到线程A执行完毕后，才会继续执行线程B。

  比如：
               t.start();
	          t.join();
              t2.start();

主线程先调用t线程执行，在分配给t线程的时间片用完之后，因为在主线程里调用了t.join( )方法，
所以下个时间片还是分配给t线程，直到t线程运行完才会唤醒阻塞的主线程，
    这时候主线程才会调用t2线程去执行	
    
   public class TestThreadJoin2 {
   public static void main(String[] args) throws InterruptedException {
	   Thread t = new Thread() {
			public void run() {
				
			for(int i=0;i<5;i++) {	
				System.out.println("线程1："+i);
			}
				
			}
		
		};
		Thread t2 = new Thread(new Runnable() {
			
			@Override
			public void run() {
				for(int i=0;i<5;i++) {
					
					System.out.println("线程2："+i);
				}
				
			}
		});
	  t.start();
	  t.join();
              t2.start();	
		
   	}
}

关于优先级设置：
每个线程执行时都有一个优先级的属性，优先级高的线程可以获得较多的执行机会，而优先级低的线程则获得较少的执行机会。
与线程休眠类似，线程的优先级仍然无法保障线程的执行次序。只不过，优先级高的线程获取CPU资源的概率较大，优先级低的也并非没机会执行。

三、线程同步与锁：synchronized
线程同步与锁的概念在多线程里重中之重，同步的概念在操作系统中讲的比较清楚，简要来说即多个线程互斥地访问临界资源，当有一个线程获得对某临界资源的访问权后，直到该线程完成对资源的操作，在这期间其他要访问该资源的线程只能处于等待状态。锁的概念即代表对临界资源的访问权。java中锁由关键字synchronized代表。
每个对象都有一个内置锁（加锁机制，为了免去显式地创建锁对象），当某个线程执行到由synchronized方法的关键字时，便获取到该对象内置锁对象，当执行到synchronized代码块时，也获取相对应的内置锁对象

同步方式：
(1)、同步方法（给方法加锁）就是用synchronize关键字修饰的方法（即同步方法）。因为每个java对象都有一个内置锁，当用synchronize关键字修饰方法时内置锁会保护整个方法，
而在调用该方法之前，要先获得内置锁，否则就会处于阻塞状态。
（2）、同步代码块：就是拥有synchronize关键字修饰的代码块（同步代码块），被该关键字修饰的语句块会自动被加上内置锁，从而实现同步

追加问题：如果同步函数被静态修饰之后，使用的锁是什么？静态方法中不能定义this！

静态内存是：内存中没有本类对象，但是一定有该类对应的字节码文件对象。 类名.class 该对象类型是Class。

所以静态的同步方法使用的锁是该方法所在类的字节码文件对象。 类名.class。代码如下：

  public static mySyn(String name){
       synchronized (Xxx.class) {
           Xxx.name = name;
          }
      }

在同一个类中
同步方法 public synchronized void method( ){
}

同步代码块 public void method2( ){
synchronized( this){
}
}
获取的是同一把锁，即当前对象锁
区别：
同步方法默认用this或者当前类class对象作为锁；
同步代码块可以选择以什么来加锁，比同步方法要更细颗粒度，我们可以选择只同步会发生同步问题的部分代码而不是整个方法；
同步方法使用关键字 synchronized修饰方法，而同步代码块主要是修饰需要进行同步的代码，用 synchronized（object）{代码内容}进行修饰；

锁池:假设线程A已经拥有了某个对象(注意:不是类)的锁，而其它的线程想要调用这个对象的某个synchronized方法(或者synchronized块)，
由于这些线程在进入对象的synchronized方法之前必须先获得该对象的锁的拥有权，但是该对象的锁目前正被线程A拥有，所以这些线程就进入了该对象的锁池中。
等待池:假设一个线程A调用了某个对象的wait()方法，线程A就会释放该对象的锁(因为wait()方法必须出现在synchronized中，这样自然在执行wait()方法之前线程A就已经拥有了该对象的锁)，同时线程A就进入到了该对象的等待池中。
如果另外的一个线程调用了相同对象的notifyAll()方法，那么处于该对象的等待池中的线程就会全部进入该对象的锁池中，准备争夺锁的拥有权。
如果另外的一个线程调用了相同对象的notify()方法，那么仅仅有一个处于该对象的等待池中的线程(随机)会进入该对象的锁池.

等待池和锁池的理解：当调用了wait()方法，释放锁资源和Cpu资源，线程进入等待池，当其他线程调用notify()会从等待池任意选择一个线程调入锁池， notifyAll()会调用所有等待池线程进入锁池，锁池里的对象可以竞争锁，优先级高的获得锁的能力更强，获得锁的线程可以进入就绪态继续执行，执行完之后释放锁，然后锁池里的线程再继续竞争

sleep(),join()和wait()区别：

sleep,join会释放Cpu资源，但不会释放锁资源，而且会自动唤醒。但是sleep()和join又有不同：
1、sleep()是自身线程调用，且阻塞超过一定时间后进入就绪态，然后获取Cpu继续执行，而join是其他线程的调用，自身线程阻塞，等待其他线程执行完后进入就绪态，然后获取Cpu让自身线程继续执行。

区别：join内部调用了wait()，是会释放锁的，其他线程可以调用该线程的同步方法，sleep()不具备放锁特点，该线程执行完才会放锁，是static的静态方法；
wait()会释放Cpu资源和锁资源，不会自动唤醒。必须要其他线程调用notify()或notifyAll()才会唤醒到达就绪态，获取Cpu后才会继续执行。

2、sleep是线程类（Thread）的方法，导致此线程暂停执行指定时间，给执行机会给其他线程，但是监控状态依然保持，到时后会自动恢复。调用sleep不会释放对象锁。
wait是Object类的方法，对此对象调用wait方法导致本线程放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象发出notify方法（或notifyAll）后本线程才进入
对象锁定池准备获得对象锁进入运行状态。