Java多线程

• • 一、多线程是什么？为什么要用多线程？
  • 二 、为什么要用多线程：
  • 三 、线程的生命周期：
  • • 四、实现方式
  • 五、继承Thread类和实现Runnable接口、实现Callable接口的区别。
  • 6 扩展：
  • • 7 线程的同步问题

介绍多线程之前要介绍线程，介绍线程则离不开进程。
　　首先 进程 ：是一个正在执行中的程序，每一个进程执行都有一个执行顺序，该顺序是一个执行路径，或者叫一个控制单元；
　　线程：就是进程中的一个独立控制单元，线程在控制着进程的执行。一个进程中至少有一个进程。
多线程：一个进程中不只有一个线程。

①、为了更好的利用cpu的资源，如果只有一个线程，则第二个任务必须等到第一个任务结束后才能进行，如果使用多线程则在主线程执行任务的同时可以执行其他任务，而不需要等待；
　　　　②、进程之间不能共享数据，线程可以；
　　　　③、系统创建进程需要为该进程重新分配系统资源，创建线程代价比较小；
　　　　④、Java语言内置了多线程功能支持，简化了java多线程编程。

新建 ：从新建一个线程对象到程序start() 这个线程之间的状态，都是新建状态；
就绪 ：线程对象调用start()方法后，就处于就绪状态，等到JVM里的线程调度器的调度；
运行 ：就绪状态下的线程在获取CPU资源后就可以执行run(),此时的线程便处于运行状态，运行状态的线程可变为就绪、阻塞及死亡三种状态。
等待/阻塞/睡眠 ：在一个线程执行了sleep（睡眠）、suspend（挂起）等方法后会失去所占有的资源，从而进入阻塞状态，在睡眠结束后可重新进入就绪状态。
终止 ：run（）方法完成后或发生其他终止条件时就会切换到终止状态。

• 继承Thread类：

步骤：①、定义类继承Thread；
　　　　　②、复写Thread类中的run方法；
　　　　目的：将自定义代码存储在run方法，让线程运行
　　　　　③、调用线程的start方法：
　　　　该方法有两步：启动线程，调用run方法。
　　　　class ThreadDemo extends Thread {
private Thread t;
private String threadName;

ThreadDemo( String name) {
threadName = name;
System.out.println("Creating " + threadName );
}

public void run() {
System.out.println("Running " + threadName );
try {
for(int i = 4; i > 0; i–) {
System.out.println("Thread: " + threadName + ", " + i);
// 让线程睡眠一会
Thread.sleep(50);
}
}catch (InterruptedException e) {
System.out.println(“Thread " + threadName + " interrupted.”);
}
System.out.println(“Thread " + threadName + " exiting.”);
}

public void start () {
System.out.println("Starting " + threadName );
if (t == null) {
t = new Thread (this, threadName);
t.start ();
}
}
}

public class TestThread {

public static void main(String args[]) {
ThreadDemo T1 = new ThreadDemo( “Thread-1”);
T1.start();

  ThreadDemo T2 = new ThreadDemo( "Thread-2");
  T2.start();

}
}

• 实现Runnable接口：

接口应该由那些打算通过某一线程执行其实 例的类来实现。类必须定义一个称为run 的无参方法。
　　　　实现步骤： ①、定义类实现Runnable接口
　　　　　　　　　　②、覆盖Runnable接口中的run方法
　　　　　　　　　　将线程要运行的代码放在该run方法中。
　　　　　　　　　　③、通过Thread类建立线程对象。
　　　　　　　　　　④、将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数。
　　　　　　　　　　　　　自定义的run方法所属的对象是Runnable接口的子类对象。所以要让线程执行指定对象的run方法就要先明确run方法所属对象
　　　　　　　　　　⑤、调用Thread类的start方法开启线程并调用Runnable接口子类的run方法。
class RunnableDemo implements Runnable {
private Thread t;
private String threadName;

RunnableDemo( String name) {
threadName = name;
System.out.println("Creating " + threadName );
}

public void run() {
System.out.println("Running " + threadName );
try {
for(int i = 4; i > 0; i–) {
System.out.println("Thread: " + threadName + ", " + i);
// 让线程睡眠一会
Thread.sleep(50);
}
}catch (InterruptedException e) {
System.out.println(“Thread " + threadName + " interrupted.”);
}
System.out.println(“Thread " + threadName + " exiting.”);
}

public void start () {
System.out.println("Starting " + threadName );
if (t == null) {
t = new Thread (this, threadName);
t.start ();
}
}
}

public class TestThread {

public static void main(String args[]) {
RunnableDemo R1 = new RunnableDemo( “Thread-1”);
R1.start();

  RunnableDemo R2 = new RunnableDemo( "Thread-2");
  R2.start();

}
}

• 通过Callable和Future创建线程：

实现步骤：①、创建Callable接口的实现类，并实现call()方法，改方法将作为线程执行体，且具有返回值。
　　　　　　　　　②、创建Callable实现类的实例，使用FutrueTask类进行包装Callable对象，FutureTask对象封装了Callable对象的call()方法的返回值
　　　　　　　　　③、使用FutureTask对象作为Thread对象启动新线程。
　　　　　　　　　④、调用FutureTask对象的get（）方法获取子线程执行结束后的返回值。
public static void main(String[] args)
{
CallableThreadTest ctt = new CallableThreadTest();
FutureTask ft = new FutureTask<>(ctt);
for(int i = 0;i < 100;i++)
{
System.out.println(Thread.currentThread().getName()+" 的循环变量i的值"+i);
if(i==20)
{
new Thread(ft,“有返回值的线程”).start();
}
}
try
{
System.out.println(“子线程的返回值：”+ft.get());
} catch (InterruptedException e)
{
e.printStackTrace();
} catch (ExecutionException e)
{
e.printStackTrace();
}

}
@Override  
public Integer call() throws Exception  
{  
    int i = 0;  
    for(;i<100;i++)  
    {  
        System.out.println(Thread.currentThread().getName()+" "+i);  
    }  
    return i;  
}  

继承Thread：线程代码存放在Thread子类run方法中。
　　　　　　　　优势：编写简单，可直接用this.getname（）获取当前线程，不必使用Thread.currentThread（）方法。
　　　　　　　　劣势：已经继承了Thread类，无法再继承其他类。
　　　　实现Runnable：线程代码存放在接口的子类的run方法中。
　　　　　　　　优势：避免了单继承的局限性、多个线程可以共享一个target对象，非常适合多线程处理同一份资源的情形。
　　　　　　　　劣势：比较复杂、访问线程必须使用Thread.currentThread（）方法、无返回值。
　　　　实现Callable：
　　　　　　　　优势：有返回值、避免了单继承的局限性、多个线程可以共享一个target对象，非常适合多线程处理同一份资源的情形。
　　　　　　　　劣势：比较复杂、访问线程必须使用Thread.currentThread（）方法
　　建议使用实现接口的方式创建多线程。

1 Java线程调度是Java多线程的核心，只有良好的调度，才能充分发挥系统的性能，
提高程序的执行效率。但是不管程序员怎么编写调度，只能最大限度的影响线程执行的次序，而不能做到精准控制。因为使用sleep方法之后，
线程是进入阻塞状态的，只有当睡眠的时间结束，才会重新进入到就绪状态，而就绪状态进入到运行状态，是由系统控制的，我们不可能精准的去干涉它，所以如果调用Thread.sleep(1000)使得线程睡眠1秒，可能结果会大于1秒。
　　2、线程让步—yield：
　　　　　该方法和sleep方法类似，也是Thread类提供的一个静态方法，可以让正在执行的线程暂停，但是不会进入阻塞状态，而是直接进入就绪状态。相当于只是将当前线程暂停一下，然后重新进入就绪的线程池中，让线程调度器重新调度一次。也会出现某个线程调用yield方法后暂停，但之后调度器又将其调度出来重新进入到运行状态。

sleep和yield的区别：
　　　　①、sleep方法声明抛出InterruptedException，调用该方法需要捕获该异常。yield没有声明异常，也无需捕获。
　　　　②、sleep方法暂停当前线程后，会进入阻塞状态，只有当睡眠时间到了，才会转入就绪状态。而yield方法调用后 ，是直接进入就绪状态。

解决办法：
对多条操作共享数据的语句，让一个线程都执行完，执行过程中，其他线程不可以参与执行。

Java对于多线程的安全问题提供了专业的解决方式：同步机制

1. 同步代码块：
   synchronized (对象){
   // 需要被同步的代码；
   }
2. synchronized还可以放在方法声明中，表示整个方法为同步方法。
   例如：
   public synchronized void show (String name){
   ….
   }