线程

线程的概念

• 线程与进程
  • 进程：系统运行的基本单位，一个进程可以看作一个运行的程序，每一个进程都有独立的内存和系统资源。
  • 线程：一个程序运行的最小单位（流控制），多个线程共享系统资源和内存。main()方法叫做进程的主线程。
    • 前台线程：主线程和Thread类生成的线程，即程序必须完成的线程。
    • 后台线程：用于内存分配的线程，不会影响程序的运行，在所有前台线程结束后结束。
• 线程的生成
  • Thread类：
    • java.lang包下，继承与Object类和实现Runnable接口
    • 线程类一般通过继承Thread类来实现
  • Runnable接口
    Runnable接口中声明了一个未实现的run方法，在实现它的具体类中可以实现run方法（run方法必须无参无返回值），具体的调用过程，start->run，所以实现类是线程对象调用Runnable接口实现对象。

//构造
public class Thread extends Object implements Runnable 
public Thread()
public Thread(String name)
public Thread(Runnable target)
public Thread(Runnable target , String name)
public Thread(ThreadGroup group , Runnable target)
public Thread(ThreadGroup group , String name)
public Thread(ThreadGroup group , Runnable target , String name)
//静态方法
public static Thread currentThread()//返回当前执行线程的引用对象
public static int activeCount()//返回当前
public static enumerate(Thread[] tarray)//线程复制
//实例方法
public final String getName()//获取当前线程的名
public final String setName()//设置当前线程名
public void start()//启动已经创建的线程对象
public final boolean isAlive()//查看线程启动状态
public final ThreadGroup getThreadGroup()//获取当前线程所在线程组
//接口实现线程对象
public class MyThread implements Runnable {
    public static void main(String args[]){
        MyThread my = new MyThread();
        Thread a = new Thread(My);
        a.start();
      ... ...(1)
}
    public void run(){
        ... ...(2)
}
}
//（1）（2）两处同时进行，体现并发性

• 两种方式比较
  Thread比较简单，能够直接操作线程；Runnable实现可以在继承其他类的情况下使用，并且可以实现共享资源

//共享资源体现
class Resource implements Runnable{
    volatile public int i;
    public Resource(int _i){
        i = _i;
    }
    public void run(){}
    ... ...
}
public class Test{
    public static void main(String args[]){
        Resource re = new Resource(100);
        Thread t1 = new Thread(re);
        Thread t2 = new Thread(re);
        t1.start();
        t2.start(); 
       }
}

t1和t2两个线程生成共享了re的资源(包括变量和方法)

• 线程组（ThreadGroup）
  java.lang包中提供ThreadGroup类用于管理一组线程，每一个线程都属于某个线程组，且只能属于一个线程组，一旦隶属关系确认就不能改变，线程产生时我们可以指定线程组或者又系统默认分配。
  线程组提供一种机制，能对它所管理的线程实行统一管理，例如得到线程数目，状态以及操作。
• volatile修饰符关键字
  因为JVM优化，线程可以把变量从主内存中读取保存在计算机的寄存器中（保存私有拷贝），所以多线程情况下，可能因为一个线程修改了主内存中的某一个变量，而另一个线程却还在使用它的寄存器中的副本，导致变量不一致。所以对于多线程情况下，所有共享的变量都应该加上volatile修饰符，使所有的线程都只能从主内存之中读取该变量，不允许保存私有拷贝。常量和定义在synchronize代码段中的变量不需要添加volatile修饰符

线程的控制和调度

线程的生命周期

线程.JPG

• 创建：new运算符生成一个线程时，该线程只是一个对象，并没有分配内存和系统资源，成为创建状态。
• 可运行：利用start()方法启动一个线程对象后，系统为该线程分配了除了CPU以外的所有资源，使线程处于runnable可运行状态。
  多个线程先后start，但是并不是顺序的启动，线程的启动取决于操作系统而不是程序，除非设置优先级（priority）
• 运行中：Java运行系统通过调度机制选中一个可运行的线程，CPU为其分配时间片，然后JVM调用它的run方法，此时此线程就处于运行状态。
  注意：如果没有先调用线程的start方法，就调用run方法,此时并没有运行线程，此时只是主线程调用线程对象的run方法
  +阻塞：线程处于不可执行状态，可以恢复运行状态
  • sleep()
    • Thread类静态方法
    • 在synchrnized代码块中不会释放对象锁，所以睡眠中其他线程也无法访问同步代码块中的内容，并且如果不设置优先级，睡眠结束后线程不一定立刻执行，必须等待调度。
    • 必须异常捕获
  • wait():
    • Object类方法
    • 只能在synchronized代码块或方法中使用，并且当执行wait()方法时，线程就进入线程等待池中并且释放对象锁让其他的线程竞争获取。
    • wait()线程等待池中线程的唤醒(必须有相同对象锁的才能被唤醒)
      通过设置唤醒时间wait(milisecond)
通过notify(随机唤醒池中的线程)或者notifyAll(唤醒池中所有的线程竞争)，高优先级获取对象锁成功率更高
    • wait()必须在synchronized代码块或者方法中，必须接notify()或notifyAll()。
  • join()
    • Thread类方法。
    • 用在main()主线程中，使得主线程中其他子线程优先执行结束，最后结束主线程。
    • 通过wait()方法实现，主线程调用t.join()实际上是主线程休眠。因为在main方法中，t.join()实际是主线程调用join()方法，谁调用谁阻塞。
• 线程调度与优先级
  • 线程调度机制：
    • 优先级：高优先级优先独占，低优先级阻塞
    • 轮换调度：多个同级线程采取时间片轮换调度，时间片一到直接阻塞。
  • 优先级：总共10级。1级最低，5级默认。每一个优先级用一个Thread类的公用静态常量来表示。

线程同步机制

• 安全问题：多个线程共同访问某个方法时，可能由于阻塞等原因，导致没有执行完全，另一个线程访问此方法时可能会修改该方法中的变量值，导致脏读（其他的程序无法读取到正确的值）

线程同步synchronized关键字

• 对象锁：一种用作线程同步保护的内置锁又称作监视器锁，线程进入同步代码块之前自动获取锁，正常退出时释放锁（JVM底层实现），以下所说的监视器其实就是获取锁。
• synchronized三种用法：

synchronized(锁对象引用){}//synchronized代码块，监视器就是此锁对象引用

public class TestSyn{
    public synchronized void method(){
   //此时监视器就是修饰方法所在的对象 
   }
}

public class TestSyn{
    public static synchronized void method(){
    //此时监视器为修饰方法所在的类，又称作类锁，主要是对该类的所有实例进行公共监视
}

• 死锁（待补充）
  多个线程被阻塞，都在等待某个线程释放。

线程间的同步通信（待补充）