[Java篇] Java 多线程基础

96
任尔东西南北疯
2016.11.25 13:25* 字数 6387

多线程编程是java编程最重要的模块之一,对于不同的OS,线程和进程的理解是不一样的,向mac os就没有progress的概念,只有Thread等,这里说说java在windos操作系统下的理解('')~

前言:线程的实现,一般有三种方法:一种是继承Thread类,一种是实现Runnable接口,还有一种是使用ExecutorService、Callable、Future实现有返回结果的多线程。,下面从这几个方面阐述内容:
1.线程和进程
2.线程的状态
3.线程的调度
4.线程的常用方法
5.线程停止、暂停与线程同步死锁
附上一些面试题~

<h1>一、线程与进程:</h1>

1.<b>进程:</b>
在操作系统中,每个独立执行的程序都可成为是一个进程,<code>正在运行的程序</code>

执行中的程序
一个进程至少包含一个线程

2.<b>线程:</b>
一个进程可以有多个执行单元同时进行,至少有一个,这些执行程序的单元就是线程,是操作系统进行调度的基本单位

程序中负责执行程序的执行单元
线程本身依靠程序的运行而存在
线程是程序的中的顺序控制流,   只能使用分配给程序的资源和环境

3.<b>单线程:</b>

程序在运行中只有一个线程,代码块就在主线程中运行,主线程就是一个单线程

4.<b>多线程:</b>

一个程序运行多个任务(并发)
实际上多线程也是程序的顺序执行,只是CPU更佳合理的被利用于线程的资源开发

<h1>Thread类:</h1>

Thread类在<code>java.lang</code>包中定义,在继承Thread类时,必须重写<code>run()</code>方法,以<code>start()</code>方法开启

class MyThread extends Thread{ 
    private static int num = 0; 
    public MyThread(){
       num++; 
    } 
    @Override 
    public void run() { 
        System.out.println("主动创建的第"+num+"个线程"); 
    }
}

创建好了自己的线程类之后,就可以创建线程对象了,然后通过<code>start()</code>方法去启动线程。<code>注意</code>:不是调用run()方法启动线程,run方法中只是定义需要执行的任务,如果调用run方法,即相当于在主线程中执行run方法,跟普通的方法调用没有任何区别,此时并不会创建一个新的线程来执行定义的任务。

public class Test { 
    public static void main(String[] args) {
           MyThread thread = new MyThread();
            thread.start();
           }
   }
class MyThread extends Thread{
    private static int num = 0; 
    public MyThread(){ 
          num++;
    }
  @Override
   public void run() { 
          System.out.println("主动创建的第"+num+"个线程");
   }
}

在上面代码中,通过调用<code>start()</code>方法,就会创建一个新的线程了。为了分清<code>start()</code>方法调用和<code>run()</code>方法调用的区别,请看下面一个例子:

public class Test { 
       public static void main(String[] args) { 
                System.out.println("主线程ID:"+Thread.currentThread().getId());
                MyThread thread1 = new MyThread("thread1");
                thread1.start();
                MyThread thread2 = new MyThread("thread2");
                 thread2.run(); 
        }
}
class MyThread extends Thread{
      private String name; 
      public MyThread(String name){ 
                this.name = name; 
      }
     @Override 
     public void run() {  
     System.out.println("name:"+name+" 子线程ID:"+Thread.currentThread().getId());
    }
}

运行结果:


1637925-5d6e74511f0b4c73.jpg

从输出结果可以得出以下结论:
(1)thread1和thread2的线程ID不同,thread2和主线程ID相同
说明通过run方法调用并不会创建新的线程,
而是在主线程中直接运行run方法,跟普通的方法调用没有任何区别;
(2)虽然thread1的start方法调用在thread2的run方法前面调用,
但是先输出的是thread2的run方法调用的相关信息,
说明新线程创建的过程不会阻塞主线程的后续执行。

[注意]:通过Thread类实现多线程。缺点:
(1)Java是单继承,实现类继承Thread类,就无法继承其他类。
(2)任务代码和线程类交织在一起,不符合OOP基本思想。


<h1>runable类</h1>

在Java中创建线程除了继承Thread类之外,还可以通过实现Runnable接口来实现类似的功能。实现Runnable接口必须重写其run方法。
下面是一个例子:
[注意]:Runnable接口:
1)Runnable是接口,不影响实现类继承其他类的关系。
2)任务代码和线程类分离,符合OOP基本思想。

public class Test {
       public static void main(String[] args) { 
               System.out.println("主线 ID:"+Thread.currentThread().getId()); 
               MyRunnable runnable = new MyRunnable(); 
               Thread thread = new Thread(runnable);
               thread.start(); 
       }
}
class MyRunnable implements Runnable{
       @Override
        public void run() { 
               System.out.println("子线 ID:"+Thread.currentThread().getId()); 
       }
}

<b>Runnable</b>的中文意思是“任务”,顾名思义,通过实现<b>Runnable</b>接口,我们定义了一个子任务,然后将子任务交由<b>Thread</b>去执行。<code>注意:</code>这种方式必须将<b>Runnable</b>作为<b>Thread</b>类的参数,然后通过<b>Thread</b>的<code>start()</code>方法来创建一个新线程来执行该子任务。如果调用<b>Runnable</b>的<b>run</b>方法的话,是不会创建新线程的,这根普通的方法调用没有任何区别。

事实上,查看<b>Thread</b>类的实现源代码会发现<b>Thread</b>类是实现了<b>Runnable</b>接口的。

在Java中,这2种方式都可以用来创建线程去执行子任务,具体选择哪一种方式要看自己的需求。直接继承<b>Thread</b>类的话,可能比实现<b>Runnable</b>接口看起来更加简洁,但是由于Java只允许单继承,所以如果自定义类需要继承其他类,则只能选择实现<b>Runnable</b>接口。

<h3>使用ExecutorService、Callable、Future实现有返回结果的多线程</h3>

<b>ExecutorService、Callable、Future</b>这个对象实际上都是属于<b>Executor</b>框架中的功能类。想要详细了解<b>Executor</b>框架的可以访问http://www.javaeye.com/topic/366591 ,这里面对该框架做了很详细的解释。返回结果的线程是在<code>JDK1.5</code>中引入的新特征,确实很实用,有了这种特征我就不需要再为了得到返回值而大费周折了,而且即便实现了也可能漏洞百出。
可返回值的任务必须实现<b>Callable</b>接口,类似的,无返回值的任务必须<b>Runnable</b>接口。执行<b>Callable</b>任务后,可以获取一个<b>Future</b>的对象,在该对象上调用<b>get</b>就可以获取到<b>Callable</b>任务返回的<b>Object</b>了,再结合线程池接口<b>ExecutorService</b>就可以实现传说中有返回结果的多线程了。下面提供了一个完整的有返回结果的多线程测试例子,在<code>JDK1.5</code>下验证过没问题可以直接使用。代码如下:

/*** 有返回值的线程 */ 
@SuppressWarnings("unchecked") 
public class Test { 
      public static void main(String[] args) throws ExecutionException, 
InterruptedException { 
           System.out.println("----程序开始运行----"); 
           Date date1 = new Date();  
           int taskSize = 5; 
           // 创建一个线程池
           ExecutorService pool = Executors.newFixedThreadPool(taskSize); 
          // 创建多个有返回值的任务  
           List<Future> list = new ArrayList<Future>();
           for (int i = 0; i < taskSize; i++) { 
                   Callable c = new MyCallable(i + " "); 
                  // 执行任务并获取Future对象  
                  Future f = pool.submit(c);
                  System.out.println(">>>" + f.get().toString());
                  list.add(f);
           } 
          // 关闭线程池
          pool.shutdown(); 
          // 获取所有并发任务的运行结果  
          for (Future f : list) { 
          // 从Future对象上获取任务的返回值,并输出到控制台  
                 System.out.println(">>>" + f.get().toString());
          }
         Date date2 = new Date(); 
         System.out.println("----程序结束运行----,程序运行时间【" 
          + (date2.getTime() - date1.getTime()) + "毫秒】"); 
    }
 } 
class MyCallable implements Callable<Object> { 
    private String taskNum;
    MyCallable(String taskNum) {
          this.taskNum = taskNum; 
    }
    public Object call() throws Exception { 
          System.out.println(">>>" + taskNum + "任务启动"); 
          Date dateTmp1 = new Date();
          Thread.sleep(1000); 
          Date dateTmp2 = new Date(); 
          long time = dateTmp2.getTime() - dateTmp1.getTime();
          System.out.println(">>>" + taskNum + "任务终止"); 
          return taskNum + "任务返回运行结果,当前任务时间【" + time + "毫秒】";
    }
}

代码说明:
上述代码中<b>Executors</b>类,提供了一系列工厂方法用于创先线程池,返回的线程池都实现了<b>ExecutorService</b>接口。
public static ExecutorService newFixedThreadPool(int nThreads)
创建固定数目线程的线程池。

public static <b>ExecutorService</b> newCachedThreadPool()
创建一个可缓存的线程池,调用execute 将重用以前构造的线程(如果线程可用)。如果现有线程没有可用的,则创建一个新线程并添加到池中。终止并从缓存中移除那些已有 60 秒钟未被使用的线程。

public static <b>ExecutorService</b> newSingleThreadExecutor()
创建一个单线程化的<b>Executor</b>。

public static<b> ScheduledExecutorService</b> newScheduledThreadPool(int corePoolSize)
创建一个支持定时及周期性的任务执行的线程池,多数情况下可用来替代Timer类。

<b>ExecutoreService</b>提供了<code>submit()</code>方法,传递一个<b>Callable</b>,或<b>Runnable</b>,返回<b>Future</b>。如果<b>Executor</b>后台线程池还没有完成<b>Callable</b>的计算,这调用返回<b>Future</b>对象的<code>get()</code>方法,会阻塞直到计算完。


<h1>二、线程的状态</h1>

在正式学习Thread类中的具体方法之前,我们先来了解一下线程有哪些状态,这个将会有助于后面对Thread类中的方法的理解。

创建(new)状态: 准备好了一个多线程的对象
就绪(runnable)状态: 调用了start()方法, 等待CPU进行调度
运行(running)状态: 执行run()方法
阻塞(blocked)状态: 暂时停止执行, 可能将资源交给其它线程使用
终止(dead)状态: 线程销毁

当需要新起一个线程来执行某个子任务时,就创建了一个线程。但是线程创建之后,不会立即进入就绪状态,因为线程的运行需要一些条件(比如内存资源,(程序计数器、<b>Java</b>栈、本地方法栈都是线程私有的,所以需要为线程分配一定的内存空间),只有线程运行需要的所有条件满足了,才进入就绪状态。

当线程进入就绪状态后,不代表立刻就能获取<b>CPU</b>执行时间,也许此时<b>CPU</b>正在执行其他的事情,因此它要等待。当得到<b>CPU</b>执行时间之后,线程便真正进入运行状态。

线程在运行状态过程中,可能有多个原因导致当前线程不继续运行下去,比如用户主动让线程睡眠(睡眠一定的时间之后再重新执行)、用户主动让线程等待,或者被同步块给阻塞,此时就对应着多个状态:<b>time waiting</b>(睡眠或等待一定的事件)、<b>waiting</b>(等待被唤醒)、<b>blocked</b>(阻塞)。

当由于突然中断或者子任务执行完毕,线程就会被消亡。

下面这副图描述了线程从创建到消亡之间的状态:

1637925-75c47af30e4e968c.jpg

在有些教程上将<b>blocked、waiting、time waiting</b>统称为阻塞状态,这个也是可以的,只不过这里我想将线程的状态和<b>Java</b>中的方法调用联系起来,所以将<b>waiting</b>和<b>time waiting</b>两个状态分离出来。

<b>sleep()</b>是<b>Thread</b>类的方法,<b>wait()</b>是<b>Object</b>类中定义的方法.
<b>Thread.sleep</b>不会导致锁行为的改变, 如果当前线程是拥有锁的, 那么<b>Thread.sleep</b>不会让线程释放锁.
<b>Thread.sleep</b>和<b>Object.wait</b>都会暂停当前的线程. <b>OS</b>会将执行时间分配给其它线程. 区别是, 调用<b>wait</b>后, 需要别的线程执行<b>notify/notifyAll</b>才能够重新获得<b>CPU</b>执行时间.


<h1>三、线程的调度</h1>

对于单核<b>CPU</b>来说(对于多核<b>CPU</b>,此处就理解为一个核),<b>CPU</b>在一个时刻只能运行一个线程,当在运行一个线程的过程中转去运行另外一个线程,这个叫做线程的调度(对于进程也是类似),常见的线程调度方法有线程休眠(sleep)、线程让步(yield)、线程插队(jion)。

由于可能当前线程的任务并没有执行完毕,所以在切换时需要保存线程的运行状态,以便下次重新切换回来时能够继续切换之前的状态运行。举个简单的例子:比如一个线程A正在读取一个文件的内容,正读到文件的一半,此时需要暂停线程A,转去执行线程B,当再次切换回来执行线程A的时候,我们不希望线程A又从文件的开头来读取。

因此需要记录线程A的运行状态,那么会记录哪些数据呢?因为下次恢复时需要知道在这之前当前线程已经执行到哪条指令了,所以需要记录程序计数器的值,另外比如说线程正在进行某个计算的时候被挂起了,那么下次继续执行的时候需要知道之前挂起时变量的值时多少,因此需要记录<b>CPU</b>寄存器的状态。所以一般来说,线程上下文切换过程中会记录程序计数器、<b>CPU</b>寄存器状态等数据。

<b>说简单点的</b>:对于线程的调度实际上就是: <b>存储和恢复CPU状态的过程,它使得线程执行能够从中断点恢复执行</b>。

虽然多线程可以使得任务执行的效率得到提升,但是由于在线程切换时同样会带来一定的开销代价,并且多个线程会导致系统资源占用的增加,所以在进行多线程编程时要注意这些因素。


<h1>四、线程的常用方法</h1>

1637925-c05980295c2d3f2b.jpg

<h2>1.静态方法</h2>

currentThread()、sleep()、yield()

<h4>1.1 currentThread()方法</h4>

<code>currentThread()</code>方法可以返回代码段正在被哪个线程调用的信息。

public class Run1{
     public static void main(String[] args){     
         System.out.println(Thread.currentThread().getName()); 
    }
}

<h4>1.2.sleep()方法</h4>

方法<code>sleep()</code>的作用是在指定的毫秒数内让当前“正在执行的线程”休眠(暂停执行)。这个“正在执行的线程”是指<b>this.currentThread()</b>返回的线程。
<h6>sleep方法有两个重载版本:</h6>

sleep(long millis) //参数为毫秒
sleep(long millis,int nanoseconds) //第一参数为毫秒,第二个参数为纳秒

<b>sleep</b>相当于让线程睡眠,交出<b>CPU</b>,让<b>CPU</b>去执行其他的任务。
但是有一点要非常注意,<code>sleep()</code>方法不会释放锁,也就是说如果当前线程持有对某个对象的锁,则即使调用<code>sleep()</code>方法,其他线程也无法访问这个对象。看下面这个例子就清楚了:

public class Test { 
     private int i = 10; 
     private Object object = new Object(); 
     public static void main(String[] args) throws IOException {
           Test test = new Test();
            MyThread thread1 = test.new MyThread(); 
            MyThread thread2 = test.new MyThread(); 
            thread1.start();
            thread2.start();
     }
 class MyThread extends Thread{
        @Override
        public void run() {
             synchronized (object) { 
                    i++; 
                     System.out.println("i:"+i); 
                      try {
                            System.out.println("线程"+
                           Thread.currentThread().getName()+"进入睡眠状态"); 
                           Thread.currentThread().sleep(10000); 

                     } catch (InterruptedException e) { 
                        // TODO: handle exception
                     }
                   System.out.println("线程"+
                     Thread.currentThread().getName()
                     +"睡眠结束"); i++; System.out.println("i:"+i);
             }
        }
}

输出结果:


1637925-39a94cb7132d82b2.jpg

从上面输出结果可以看出,当<b>Thread-0</b>进入睡眠状态之后,<b>Thread-1</b>并没有去执行具体的任务。只有当<b>Thread-0</b>执行完之后,此时<b>Thread-0</b>释放了对象锁,<b>Thread-1</b>才开始执行。

<code>注意:</code>如果调用了<b>sleep</b>方法,必须捕获<b>InterruptedException</b>异常或者将该异常向上层抛出。当线程睡眠时间满后,不一定会立即得到执行,因为此时可能<b>CPU</b>正在执行其他的任务。所以说调用<b>sleep</b>方法相当于让线程进入阻塞状态。

<h4>1.3.yield()方法</h4>

调用yield方法会让当前线程交出CPU权限,让CPU去执行其他的线程。它跟sleep方法类似,同样不会释放锁。但是yield不能控制具体的交出CPU的时间,另外,yield方法只能让拥有相同优先级的线程有获取CPU执行时间的机会。

注意,调用yield方法并不会让线程进入阻塞状态,而是让线程重回就绪状态,它只需要等待重新获取CPU执行时间,这一点是和sleep方法不一样的。
代码:

public class MyThread extends Thread{ 
     @Override 
     public void run() { 
             long beginTime=System.currentTimeMillis(); 
             int count=0;
             for (int i=0;i<50000000;i++){  
                   count=count+(i+1); 
                   //Thread.yield();
            }
           long endTime=System.currentTimeMillis();
           System.out.println("用时:"+(endTime-beginTime)+" 毫秒!"); 
     }
}
public class Run { 
       public static void main(String[] args) { 
              MyThread t= new MyThread(); t.start();
       }
}

执行结果:

用时:3 毫秒!

如果将 //Thread.yield();的注释去掉,执行结果如下:

用时:16080 毫秒!

<h2>2.对象方法</h2>

run()、getId()、isAlive()、join()、getName和setName、getPriority和setPriority、setDaemon和isDaemon

<h4>2.1.start()方法</h4>
start()用来启动一个线程,当调用start方法后,系统才会开启一个新的线程来执行用户定义的子任务,在这个过程中,会为相应的线程分配需要的资源。
<h4>2.2.run()方法</h4>

<code>run()</code>方法是不需要用户来调用的,当通过<b>start</b>方法启动一个线程之后,当线程获得了<b>CPU</b>执行时间,便进入<b>run</b>方法体去执行具体的任务。注意,继承<b>Thread</b>类必须重写<b>run</b>方法,在<b>run</b>方法中定义具体要执行的任务。
<h4>2.3. getId()</h4>

<code>getId()</code>的作用是取得线程的唯一标识
代码:

public class Test { 
   public static void main(String[] args) { 
      Thread t= Thread.currentThread(); 
      System.out.println(t.getName()+" "+t.getId()); 
   }
}

输出:

main 1

<h4>2.4.isAlive()方法</h4>

方法<b>isAlive()</b>的功能是判断当前线程是否处于活动状态

代码:

public class MyThread extends Thread{
  @Override 
  public void run() {
     System.out.println("run="+this.isAlive()); 
  }
}
public class RunTest { 
     public static void main(String[] args) throws InterruptedException { 
           MyThread myThread=new MyThread(); 
           System.out.println("begin =="+myThread.isAlive());
           myThread.start(); 
           System.out.println("end =="+myThread.isAlive());
    }
}

程序运行结果:

begin ==false  run=true  end ==false

方法isAlive()的作用是测试线程是否偶处于活动状态。什么是活动状态呢?活动状态就是线程已经启动且尚未终止。线程处于正在运行或准备开始运行的状态,就认为线程是“存活”的。
有个需要注意的地方

System.out.println("end =="+myThread.isAlive());

虽然上面的实例中打印的值是<b>true</b>,但此值是不确定的。打印<b>true</b>值是因为<b>myThread</b>线程还未执行完毕,所以输出<b>true</b>。如果代码改成下面这样,加了个<b>sleep</b>休眠:

public static void main(String[] args) throws InterruptedException { 
          MyThread myThread=new MyThread(); 
          System.out.println("begin =="+myThread.isAlive()); 
          myThread.start(); 
          Thread.sleep(1000); 
          System.out.println("end =="+myThread.isAlive()); 
}

则上述代码运行的结果输出为<b>false</b>,因为<b>mythread</b>对象已经在1秒之内执行完毕。
<h4>2.5. join()方法</h4>

在很多情况下,主线程创建并启动了线程,如果子线程中药进行大量耗时运算,主线程往往将早于子线程结束之前结束。这时,如果主线程想等待子线程执行完成之后再结束,比如子线程处理一个数据,主线程要取得这个数据中的值,就要用到<code>join()</code>方法了。方法<code>join()</code>的作用是等待线程对象销毁。

public class Thread4 extends Thread{ 
       public Thread4(String name) { 
            super(name); 
       } 
       public void run() { 
           for (int i = 0; i < 5; i++) {                       
               System.out.println(getName() + " " + i); 
           }
       } 
       public static void main(String[] args) throws InterruptedException {
           // 启动子进程 
           new Thread4("new thread").start(); 
           for (int i = 0; i < 10; i++) { if (i == 5) {
                  Thread4 th = new Thread4("joined thread");  
                  th.start(); 
                  th.join(); 
            } 
          System.out.println(Thread.currentThread().getName() + " " + i);
      }
}

执行结果:

main 0
main 1
main 2
main 3
main 4
new thread 0
new thread 1
new thread 2
new thread 3
new thread 4
joined thread 0
joined thread 1
joined thread 2
joined thread 3
joined thread 4
main 5
main 6
main 7
main 8
main 9

由上可以看出main主线程等待joined thread线程先执行完了才结束的。如果把th.join()这行注释掉,运行结果如下:

main 0
main 1
main 2
main 3
main 4
main 5
main 6
main 7
main 8
main 9
new thread 0
new thread 1
new thread 2
new thread 3
new thread 4
joined thread 0
joined thread 1
joined thread 2
joined thread 3
joined thread 4

<h4>2.6.getName和setName</h4>
用来得到或者设置线程名称。
<h4>2.7.getPriority和setPriority</h4>
用来获取和设置线程优先级。
<h4>2.8.setDaemon和isDaemon</h4>
用来设置线程是否成为守护线程和判断线程是否是守护线程。
守护线程和用户线程的区别在于:守护线程依赖于创建它的线程,而用户线程则不依赖。举个简单的例子:如果在<b>main</b>线程中创建了一个守护线程,当<b>main</b>方法运行完毕之后,守护线程也会随着消亡。而用户线程则不会,用户线程会一直运行直到其运行完毕。在JVM中,像垃圾收集器线程就是守护线程。
<b>在上面已经说到了<b>Thread</b>类中的大部分方法,那么<b>Thread</b>类中的方法调用到底会引起线程状态发生怎样的变化呢?下面一幅图就是在上面的图上进行改进而来的:</b>

<h1>五、线程停止、暂停与线程同步死锁</h1>
<h4>5.1.停止线程</h4>

停止线程是在多线程开发时很重要的技术点,掌握此技术可以对线程的停止进行有效的处理。
停止一个线程可以使用<code>Thread.stop()</code>方法,但最好不用它。该方法是不安全的,已被弃用。
在Java中有以下3种方法可以终止正在运行的线程:

使用退出标志,使线程正常退出,也就是当<b>run</b>方法完成后线程终止
使用<b>stop</b>方法强行终止线程,但是不推荐使用这个方法,因为<b>stop</b>和<b>suspend</b>及<b>resume</b>一样,都是作废过期的方法,使用他们可能产生不可预料的结果。
使用<b>interrupt</b>方法中断线程,但这个不会终止一个正在运行的线程,还需要加入一个判断才可以完成线程的停止。

<h4>5.2.暂停线程</h4>

interrupt()方法

<h4>线程的优先级</h4>

在操作系统中,线程可以划分优先级,优先级较高的线程得到的CPU资源较多,也就是<b>CPU</b>优先执行优先级较高的线程对象中的任务。
设置线程优先级有助于帮“线程规划器”确定在下一次选择哪一个线程来优先执行。
设置线程的优先级使用<code>setPriority()</code>方法,此方法在JDK的源码如下:

[注意]:优先级只代表获得更多的执行机会,不代表绝对一定的优先执行。 具体执行最终取决于操作系统。

public final void setPriority(int newPriority) { 
           ThreadGroup g; checkAccess(); 
                      if (newPriority > MAX_PRIORITY || newPriority < MIN_PRIORITY) {
                                throw new IllegalArgumentException(); 
                      }
                      if((g = getThreadGroup()) != null) {
                                 if (newPriority > g.getMaxPriority()) { 
                                       newPriority = g.getMaxPriority(); 
                                  }
             setPriority0(priority = newPriority); 
             }
 }

在<b>Java</b>中,线程的优先级分为1~10这10个等级,如果小于1或大于10,则JDK抛出异常<b>throw new IllegalArgumentException()</b>。
JDK中使用3个常量来预置定义优先级的值,代码如下:

public final static int MIN_PRIORITY = 1;
public final static int NORM_PRIORITY = 5;
public final static int MAX_PRIORITY = 10;

线程优先级特性:

    继承性
    比如A线程启动B线程,则B线程的优先级与A是一样的。
    规则性
    高优先级的线程总是大部分先执行完,但不代表高优先级线程全部先执行完。
    随机性
    优先级较高的线程不一定每一次都先执行完。

线程安全问题,产生的原因是多个线程同时操作同一资源 导致逻辑错乱。

<h4>3.守护线程</h4>

在Java线程中有两种线程,一种是<b>User Thread</b>(用户线程),另一种是<b>Daemon Thread</b>(守护线程)。
<b>Daemon</b>的作用是为其他线程的运行提供服务,比如说GC线程。其实<b>User Thread</b>线程和<b>Daemon Thread</b>守护线程本质上来说去没啥区别的,唯一的区别之处就在虚拟机的离开:如果<b>User Thread</b>全部撤离,那么<b>Daemon Thread</b>也就没啥线程好服务的了,所以虚拟机也就退出了。

守护线程并非虚拟机内部可以提供,用户也可以自行的设定守护线程,方法:<b>public final void setDaemon(boolean on) </b>;但是有几点需要注意:

<b>thread.setDaemon(true)</b>必须在<b>thread.start()</b>之前设置,否则会跑出一个<b>IllegalThreadStateException</b>异常。你不能把正在运行的常规线程设置为守护线程。 (备注:这点与守护进程有着明显的区别,守护进程是创建后,让进程摆脱原会话的控制+让进程摆脱原进程组的控制+让进程摆脱原控制终端的控制;所以说寄托于虚拟机的语言机制跟系统级语言有着本质上面的区别)

在<b>Daemon</b>线程中产生的新线程也是<b>Daemon</b>的。 (这一点又是有着本质的区别了:守护进程<code>fork()</code>出来的子进程不再是守护进程,尽管它把父进程的进程相关信息复制过去了,但是子进程的进程的父进程不是<b>init</b>进程,所谓的守护进程本质上说就是“父进程挂掉,<b>init</b>收养,然后文件0,1,2都是/dev/null,当前目录到/”)

不是所有的应用都可以分配给<b>Daemon</b>线程来进行服务,比如读写操作或者计算逻辑。因为在<b>Daemon Thread</b>还没来的及进行操作时,虚拟机可能已经退出了。

<h4>4.同步与死锁</h4>

1.同步代码块
在代码块上加上"<b>synchronized</b>"关键字,则此代码块就称为同步代码块

2.同步代码块格式

synchronized(同步对象){ 需要同步的代码块;}

3.同步方法
除了代码块可以同步,方法也是可以同步的
4.方法同步格式

synchronized void 方法名称(){}

<h1>面试题</h1>
<h4>1.线程和进程有什么区别?</h4>
答:一个进程是一个独立(<b>self contained</b>)的运行环境,它可以被看作一个程序或者一个应用。而线程是在进程中执行的一个任务。线程是进程的子集,一个进程可以有很多线程,每条线程并行执行不同的任务。不同的进程使用不同的内存空间,而所有的线程共享一片相同的内存空间。别把它和栈内存搞混,每个线程都拥有单独的栈内存用来存储本地数据。
<h4>2.如何在Java中实现线程?</h4>
答:创建线程有两种方式:一、继承 Thread 类,扩展线程。二、实现 Runnable 接口。
<h4>3.启动一个线程是调用run()还是start()方法?</h4>
答:启动一个线程是调用<code>start()</code>方法,使线程所代表的虚拟处理机处于可运行状态,这意味着它可以由<b>JVM</b> 调度并执行,这并不意味着线程就会立即运行。<code>run()</code>方法是线程启动后要进行回调(<b>callback</b>)的方法。

<h4>4.Thread类的sleep()方法和对象的wait()方法都可以让线程暂停执行,它们有什么区别?</h4>
答:<code>sleep()</code>方法(休眠)是线程类(<b>Thread</b>)的静态方法,调用此方法会让当前线程暂停执行指定的时间,将执行机会(<b>CPU</b>)让给其他线程,但是对象的锁依然保持,因此休眠时间结束后会自动恢复(请参考线程状态转换图)。<code>wait()</code>是Object类的方法,调用对象的<code>wait()</code>方法导致当前线程放弃对象的锁(线程暂停执行),进入对象的等待池(<b>wait pool</b>),只有调用对象的<code>notify()</code>方法(或<code>notifyAll()</code>方法)时才能唤醒等待池中的线程进入等锁池(<b>lock pool</b>),如果线程重新获得对象的锁就可以进入就绪状态。
<h4>5.线程的sleep()方法和yield()方法有什么区别?</h4>
答:① <b>sleep()</b>方法给其他线程运行机会时不考虑线程的优先级,因此会给低优先级的线程以运行的机会;<code>yield()</code>方法只会给相同优先级或更高优先级的线程以运行的机会;
② 线程执行<code>sleep()</code>方法后转入阻塞(<b>blocked</b>)状态,而执行<code>yield()</code>方法后转入就绪(<b>ready</b>)状态;
③ <code>sleep()</code>方法声明抛出<b>InterruptedException</b>,而<code>yield()</code>方法没有声明任何异常;
④<code> sleep(/)</code>方法比<code>yield()</code>方法(跟操作系统CPU调度相关)具有更好的可移植性。
<h4>6.请说出与线程同步以及线程调度相关的方法。</h4>
答:<b>wait()</b>:使一个线程处于等待(阻塞)状态,并且释放所持有的对象的锁;
<b>sleep()</b>:使一个正在运行的线程处于睡眠状态,是一个静态方法,调用此方法要处理<b>InterruptedException</b>异常;
<b>notify()</b>:唤醒一个处于等待状态的线程,当然在调用此方法的时候,并不能确切的唤醒某一个等待状态的线程,而是由JVM确定唤醒哪个线程,而且与优先级无关;
<b>notityAll()</b>:唤醒所有处于等待状态的线程,该方法并不是将对象的锁给所有线程,而是让它们竞争,只有获得锁的线程才能进入就绪状态;

参考文献:http://www.jianshu.com/p/4e2343cf747b

厚积薄发
Web note ad 1