【Java多线程编程核心技术】学习笔记--第1章

进程和线程：

进程可以看成一个个系统中运行的程序，而线程可以理解成是进程中独立运行的子任务。

优点：使用多线程后，可以在同一时间内运行更多不同种类的任务。

使用多线程：（代码的运行结果与代码执行顺序或调用顺序是无关的）

• 继承Thread类

先看Thread源码：
public class Thread implements Runnable
可以看出Thread类实现了Runnable接口，它们之间具有多态的关系。但这种方法的局限在于：不支持多继承

• 实现Runnable接口

如果创建的线程已经有一个父类了，这时就不能再继承Thread类了，于是需要实现Runnable接口。

---

不共享数据的情况：

/**
 * Created by Administrator on 2017/2/20/020.
 */
public class MyThread extends Thread {
    public MyThread(String name){
        super();
        this.setName(name);
    }
    private  int count = 5;

    @Override
    public void run() {
        super.run();
        while (count > 0){
            count--;
            System.out.println("由"+this.currentThread().getName()+"计算，count="+count);
        }
    }

}

/**
 * Created by LeeHom on 2017/3/20/020.
 */
public class Run {
    public static void main(String[] args) {
        MyThread a = new MyThread("A");
        MyThread b = new MyThread("B");
        MyThread c = new MyThread("C");
        a.start();
        b.start();
        c.start();
    }
}

结果

共享数据情况：

/**
 * Created by Administrator on 2017/3/20.
 */
public class MyThread extends Thread {
    private  int count = 5;

    @Override
    public void run() {
        super.run();
            count--;
            System.out.println("由"+this.currentThread().getName()+"计算，count="+count);

    }

}

/**
 * Created by Administrator on 2017/3/20.
 */
public class Run {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        Thread a = new Thread(myThread,"A");
        Thread b = new Thread(myThread,"B");
        Thread c = new Thread(myThread,"C");
        Thread d = new Thread(myThread,"D");
        Thread e = new Thread(myThread,"E");


        a.start();
        b.start();
        c.start();
        d.start();
        e.start();
    }
}

结果

通过结果发现线程A和B的count都是3，出现了非线程安全的问题，解决此问题只需要在run()前加一个synchronized关键字。synchronized可以对任意对象及方法上加锁。

/**
 * Created by Administrator on 2017/3/20.
 */
public class MyThread extends Thread {
    private  int count = 5;

    @Override
    synchronized public void run() {
        super.run();
            count--;
            System.out.println("由"+this.currentThread().getName()+"计算，count="+count);

    }

}

加上 synchronized 后

---

currentThread() : 可以返回代码段正在被哪个线程调用的信息

isAlive() : 判断当前的线程是否处于活动状态

sleep()：作用是在指定的毫秒数内让【当前正在执行的线程】休眠，这个正在执行的线程指的是this.currentThread()返回的线程。

yield()：作用是放弃当前的CPU资源，将它让给其他的任务去占用CPU执行时间。但放弃的时间不确定，有可能刚刚放弃，马上又获得CPU时间片。

• sleep例：

public class MyThread1 extends Thread {
    @Override
    public void run() {
        super.run();
        try{
            System.out.println("run threadName="+this.currentThread().getName()+"begin="+System.currentTimeMillis());
            Thread.sleep(2000);
            System.out.println("run threadName="+this.currentThread().getName()+"end="+System.currentTimeMillis());
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}

public class Run {
    public static void main(String[] args) {

        MyThread1 myThread1 = new MyThread1();
        System.out.println("begin="+System.currentTimeMillis());
        myThread1.start();
        System.out.println("end="+System.currentTimeMillis());

    }
}

结果：run threadName=Thread-0end=1490021893169是过两秒出现的

结果

---

停止线程

• 停止一个线程意味着在线程处理完任务之前停掉正在做的操作，也就是放弃当前的操作。大多数停止一个线程的操作使用的是Thread.interrupt()，这个方法不会终止一个正在运行的线程，还需要加一个判断才可以完成线程的停止

• 判断线程是否是停止状态
  Thread.java提供了两种方法

  • this.interrupted()：返回布尔类型，测试当前线程是否处于中断状态，执行后会将状态标志清除为false

public class Run {
    public static void main(String[] args) {
        Thread.currentThread().interrupt();
        System.out.println("是否停止1？="+Thread.interrupted());
        System.out.println("是否停止2？="+Thread.interrupted());
        System.out.println("end!");
    }
}

this.interrupted()

• this.isInterrupted()：返回布尔，测试线程Thread 对象是否已经是中断状态，但不清除状态标志

public class Run {
    public static void main(String[] args) {
        Thread.currentThread().interrupt();
        System.out.println("是否停止1？="+Thread.isInterrupted());
        System.out.println("是否停止2？="+Thread.isInterrupted());
        System.out.println("end!");
    }
}

结果：（没有清除状态标志）
是否停止1？=true 是否停止2？=true

线程的优先级

在操作系统中，线程可以划分优先级，优先级较高的线程可以得到的CPU资源较多，也就是CPU优先执行优先级较高的线程对象中的任务。设置线程优先级使用setPriority()方法。

• 线程的优先级具有继承性，比如A线程启动B线程，则B线程的优先级与A是一样的
• 优先级具有规则性

高优先级的线程总是大部分先执行完，但不代表高优先级的线程全部执行完，当线程优先级差距很大时，谁先执行完和代码的调用顺序无关。

**结论：优先级较高的线程，并不一定每次都先执行完run()方法中的任务，他们的关系具有不确定性和随机性 **

守护线程

在java线程中有两种线程，一种是用户线程，一种是守护线程。只要当前JVM实例中存在任何一个非守护线程没有结束，守护线程就在工作，只有当最后一个非守护线程结束时，守护线程才和JVM一起结束工作。【典型的守护线程就是垃圾回收线程】