【java】-- 多线程快速入门

1、什么是进程？什么是线程？两者区别？

　　1、每个正在系统上运行的程序都是一个进程，每个进程包含一到多个线程，多线程处理就是允许一个进程中在同一时刻执行多个任务。

　　2、线程是一组指令的集合，或者是程序的特殊段，它可以在程序里独立执行。也可以把它理解为代码运行的上下文。

　　3、进程是所有线程的集合，每一个线程是进程中的一条执行路径。

　　4、线程基本上是轻量级的进程，与进程相比创建代价或开销较小。

　　5、通常由操作系统负责多个线程的调度和执行，Java线程由虚拟机负责调度。

2、为什么要使用多线程？有什么弊端？

　　多线程的好处提高程序的效率。例如：使用线程把占据时间长的程序中的任务放到后台去处理，程序的运行速度可能加快，在一些等待的任务实现上如用户输入、文件读写和网络收发数据等，线程就比较有用了。在这种情况下可以释放一些珍贵的资源如内存占用等等。

　　但是线程也不是越多越好，如果有大量的线程会影响性能，因为：

　　　　1、操作系统需要在它们之间切换

　　　　2、更多的线程需要更多的内存空间

　　　　3、线程的中止需要考虑其对程序运行的影响

　　　　4、通常块模型数据是在多个线程间共享的，需要防止线程死锁情况的发生。

3、多线程应用场景

　　举例: 迅雷多线程下载、分批发送短信等需要使用多线程提高程序效率场景。

4、多线程创建方式

　　1、使用继承Thread类方式 继承Thread类重写run方法

　　2、使用实现runnabe接口方式

　　3、使用匿名内部类方式

　　4、callable（后续文章再介绍）

　　5、使用线程池创建线程。（后续文章再介绍）

4.1、第一种继承Thread类 重写run方法

class CreateThreadDemo01 extends Thread {
 
    /**
     * run方法就是线程需要执行的任务或者执行的代码
     */
    @Override
    public void run() {
        for (int i = 0; i < 30; i++) {
            System.out.println("run,i:" + i);
        }
 
    }
 
}
 
/**
 *
 * @classDesc: 功能描述:(如何创建多线程)
 * @author: 李海滨
 * @createTime: 2017.05.12
 * @version: v1.0
 */
public class Test {
 
    public static void main(String[] args) {
        // 1. 怎么调用线程
        CreateThreadDemo01 t1 = new CreateThreadDemo01();
        // 2.启动线程 不是调用run方法，而是调用start方法。
        // 3.开启多线程后，代码不会从上往下进行执行，开始异步执行，如果调用run方法就是同步执行。
        t1.start();
        for (int i = 0; i < 30; i++) {
            System.out.println("main,i:" + i);
        }
    }
 
}

继承Hread类 重写run方法

　　输出结果：　　

　　

　　调用start方法后，代码并没有从上往下执行，而是多了一条新的执行路径开始执行，且两条执行路径互不干扰。

4.2、第二种实现Runnable接口,重写run方法

class CreateThreadDemo02 implements Runnable {
 
    @Override
    public void run() {
        for (int i = 0; i < 30; i++) {
            System.out.println("子线程 run,i:" + i);
        }
 
    }
 
}
 
/**
 *
 * @classDesc: 功能描述:(使用Runnable接口创建多线程)
 * @author: 李海滨
 * @createTime: 2017.05.12
 * @version: v1.0
 */
public class Test {
 
    public static void main(String[] args) {
        CreateThreadDemo02 t1 = new CreateThreadDemo02();
        Thread thread = new Thread(t1);
        thread.start();
        for (int i = 0; i < 30; i++) {
            System.out.println("主线程 i:" + i);
        }
 
    }
 
}

4.3、第三种使用匿名内部类方式

　　此方法除了自己学习测试之外，基本不会使用。

/**
 *
 * @classDesc: 功能描述:使用匿名内部类创建多线程
 * @author: 李海滨
 * @createTime: 2017.05.12
 * @version: v1.0
 */
public class Test {
 
    public static void main(String[] args) {
        Thread t1 = new Thread(new Runnable() {
 
            @Override
            public void run() {
                   // 需要线程执行的代码
                for (int i = 0; i < 30; i++) {
                    System.out.println("子线程，i:"+i);
                }
            }
        });
        t1.start();
        for (int i = 0; i < 30; i++) {
            System.out.println("主线程，i:"+i);
        }
 
    }
 
}

4.4、思考

　　使用继承Thread类还是使用实现Runnable接口好？

　　使用实现Runnable接口好，原因实现了接口还可以继续继承，继承了类不能再继承，低耦合。

　　使用实现Runnable接口还可以做到线程共享（之后在介绍）。

　　启动线程是使用调用start方法还是run方法？

　　使用start方法异步，使用run方法同步调用

5、线程对象的常用API

常用线程api方法
start()	启动线程
currentThread()	获取当前线程对象
getID()	获取当前线程ID      Thread-编号  该编号从0开始
getName()	获取当前线程名称
sleep(long mill)	休眠线程
Stop()	停止线程,
常用线程构造函数
Thread（）	分配一个新的 Thread 对象
Thread（String name）	分配一个新的 Thread对象，具有指定的 name正如其名。
Thread（Runable r）	分配一个新的 Thread对象
Thread（Runable r, String name）	分配一个新的 Thread对象

更多API后面在介绍

class CreateThread05 implements Runnable {
 
    // getId() 线程的id 唯一， 不会重复。
    @Override
    public void run() {
 
        for (int i = 0; i < 20; i++) {
            try {
                //单位为毫秒
                Thread.sleep(1000);
            } catch (Exception e) {
                // TODO: handle exception
            }
 
//            下面两种写法都可以
//            System.out.println("线程id:" + getId() + ":子线程 ,i:" + i + "name:" + getName());
            System.out.println("线程id:" + Thread.currentThread().getId() + ":子线程 ,i:" + i + "name:" +Thread.currentThread().getName());
            if(i==5){
                 Thread.currentThread().stop();// 不安全，不建议使用。那如何停止线程呢？后面的文章会讲到。
            }
 
        }
 
    }
}
 
/**
 *
 * @author: 李海滨
 * @createTime: 2017.05.13
 * @version: v1.0
 */
public class Test {
 
    public static void main(String[] args) {
        // 获取主线程的id
        // 任何一个程序肯定有一个主线程
        // Thread.currentThread()获取到当前线程对象
        System.out.println("主线程:" + Thread.currentThread().getId() + ",name:" + Thread.currentThread().getName());
 
        CreateThread05 t1 = new CreateThread05();
        Thread thread = new Thread(t1,"子线程");
        thread.start();
 
    }
 
}

6、守护线程

　　什么是守护线程？

　　　　Java中有两种线程，一种是用户线程，另一种是守护线程。

　　　　用户线程是指用户自定义创建的线程，主线程停止，用户线程不会停止

　　　　守护线程当进程不存在或主线程停止，守护线程也会被停止。

　　如何设置守护线程？

　　　　使用setDaemon(true)方法

public class Test005 {
 
    public static void main(String[] args) {
        Thread t1 = new Thread(new Runnable() {
            public void run() {
                for (int i = 0; i < 30; i++) {
                    try {
                        Thread.sleep(300);
                    } catch (Exception e) {
                        // TODO: handle exception
                    }
                    System.out.println("子线程,i:" + i);
                }
            }
        });
        t1.setDaemon(true);//该线程为守护线程 和主线程一起销毁
        t1.start();
        for (int i = 0; i < 5; i++) {
            try {
                Thread.sleep(300);
            } catch (Exception e) {
                // TODO: handle exception
            }
            System.out.println("主线程,i:" + i);
        }
        System.out.println("主线程执行完毕.....");
    }
 
}

7、多线程运行状态

　　线程从创建、运行到结束总是处于下面五个状态之一：新建状态、就绪状态、运行状态、阻塞状态及死亡状态。

　　本小节参考：多线程的执行流程以及各个状态描述  该文章内有代码演示方便理解。

7.1、新建状态

　　当用new操作符创建一个线程时， 例如new Thread(r)，线程还没有开始运行，此时线程处在新建状态。

7.2、就绪状态

　　当我们调用了新建状态下的线程对象的 start() 方法来启动这个线程，并且线程对象已经准备好了除CPU时间片段之外的所有资源后，该线程对象会被放入“可运行线程池”中等待CPU分配时间片段给自身。在自身获得CPU的时间片段之后便会执行自身 run() 方法中定义的逻辑。

7.3、运行状态

　　当线程获得CPU时间后，它才进入运行状态，真正开始执行run()方法。

　　1、但是生产环境中的线程对象的 run() 方法一般不会这么简单，可能业务代码逻辑复杂，造成CPU的时间片段所规定的时长已经用完之后，业务代码还没执行完；

　　2、或者是当前线程主动调用了Thread.yield()方法来让出自身的CPU时间片段。（后面介绍）

7.4、阻塞状态

　　阻塞状态指的是运行状态中的线程因为某种原因主动放弃了自己的CPU时间片段来让给其他线程使用，可能的阻塞类型及原因有：

　 1）等待阻塞

　　线程被调用了 Object.wait() 方法后会立刻释放掉自身获取到的锁并进入“等待池”进行等待，等待池中的线程被其他线程调用了 Object.notify() 或 Object.notifyAll() 方法后会被唤醒从而从“等待池”进入到“等锁池”，“等锁池”中的线程在重新获取到锁之后会转为可运行状态。

　　值得注意的是：wait()和notify()/notifyAll()只能用在被synchronized包含的代码块中，而说明中的Object.wait和Object.notify的这个Object实际上是指作为synchronized锁的对象。

　  2）同步阻塞

　　线程执行到了被 synchronized 关键字保护的同步代码时，如果此时锁已经被其他线程取走，则该线程会进入到“等锁池”，直到持有锁的那个线程释放掉锁并且自身获取到锁之后，自身会转为可运行状态。

　  3）其他阻塞

　　1、线程中执行了 Thread.sleep(xx) 方法进行休眠会进入阻塞状态，直到Thread.sleep(xx)方法休眠的时间超过参数设定的时间而超时后线程会转为可运行状态。注意这里不用进入等待池或等锁池。

　　　  2、线程ThreadA中调用了ThreadB.join()方法来等待ThreadB线程执行完毕，从而ThreadA进入阻塞状态，直到ThreadB线程执行完毕后ThreadA会转为可运行状态。

7.5、死亡状态

　　有两个原因会导致线程死亡：
 
　　1、 run方法或main方法正常退出而自然死亡，
  　　2、一个未捕获的异常终止了run方法而使线程猝死。

7.6、如何判断线程是否存活？　　

　　程序运行时可能出现异常导致线程死亡，那如何来判断线程是否存活呢？使用isAlive方法：

　　　　1、如果是可运行或被阻塞，这个方法返回true；

　　　　2、如果线程仍旧是new状态且不是可运行的， 或者线程死亡了，则返回false.

8、join()方法作用

　　join作用是让其他线程变为等待,   例如： t1.join();// 让其他线程变为等待，直到当前t1线程执行完毕，才释放。

　　thread.Join把指定的线程加入到当前线程，可以将两个交替执行的线程合并为顺序执行的线程。比如在线程B中调用了线程A的Join()方法，直到线程A执行完毕后，才会继续执行线程B。

8.1、一个关于join的小问题

　　现在有T1、T2、T3三个线程，你怎样保证T2在T1执行完后执行，T3在T2执行完后执行 ？

public class Test006 {
 
    public static void main(String[] args) {
        Thread t1 = new Thread(new Runnable() {
 
            @Override
            public void run() {
                for (int i = 0; i < 20; i++) {
                    System.out.println("T1,i:" + i);
                }
            }
        });
        t1.start();
        Thread t2 = new Thread(new Runnable() {
 
            @Override
            public void run() {
                try {
                    t1.join();
                } catch (Exception e) {
                    // TODO: handle exception
                }
                for (int i = 0; i < 20; i++) {
                    try {
                        Thread.sleep(30);
                    } catch (Exception e) {
                        // TODO: handle exception
                    }
                    System.out.println("T2,i:" + i);
                }
            }
        });
 
        t2.start();
        Thread t3 = new Thread(new Runnable() {
 
            @Override
            public void run() {
                try {
                    t2.join();
                } catch (Exception e) {
                    // TODO: handle exception
                }
                for (int i = 0; i < 20; i++) {
                    try {
                        Thread.sleep(30);
                    } catch (Exception e) {
                        // TODO: handle exception
                    }
                    System.out.println("T3,i:" + i);
                }
            }
        });
 
        t3.start();
    }
 
}

8.2、优先级

　　由join方法的使用，我们可以知道线程中有着优先级的概念。

　　现代操作系统基本采用时分的形式调度运行的线程，线程分配得到的时间片的多少决定了线程使用处理器资源的多少，也对应了线程优先级这个概念。

　　在JAVA线程中，通过一个int priority来控制优先级，范围为1-10，其中10最高，默认值为5。

　　注意设置了优先级， 不代表每次都一定会被执行或是最先执行。 只是CPU调度会优先分配

8.3、Yield方法

　　Thread.yield()方法的作用：暂停当前正在执行的线程，并执行其他线程。（可能没有效果）

　　yield()让当前正在运行的线程回到可运行状态，以允许具有相同优先级的其他线程获得运行的机会。因此，使用yield()的目的是让具有相同优先级的线程之间能够适当的轮换执行。

　　但是，实际中无法保证yield()达到让步的目的，因为，让步的线程可能被线程调度程序再次选中。

　　结论：大多数情况下，yield()将导致线程从运行状态转到可运行状态，但有可能没有效果。

9、应用实例

　　需求：目前有10万个用户，给每个用户发送一条祝福短信。

分析：

　　如果使用单线程实现，假设给一个用户发送一条短信需要1秒，10万个就是10万秒。而且，如果程序出现错误中断，则中断处之后的用户均收不到短信。

　　如果使用多线程实现，很明显效率提高，开几个线程就比单线程多几倍的效率，并且，如果某一个线程出现错误中断，不会对其他线程有影响。

代码实现：

public class UserEntity {
    private String userId;
    private String userName;
 
    public UserEntity(String userId, String userName) {
        super();
        this.userId = userId;
        this.userName = userName;
    }
 
    public String getUserId() {
 
        return userId;
    }
 
    public void setUserId(String userId) {
 
        this.userId = userId;
    }
 
    public String getUserName() {
 
        return userName;
    }
 
    public void setUserName(String userName) {
 
        this.userName = userName;
    }
 
    @Override
    public String toString() {
        return "UserEntity [userId=" + userId + ", userName=" + userName + "]";
    }
 
}

实体类

public class ListUtils {
    /**
     *
     * @methodDesc: 功能描述:list 集合分批切割
     * @author: lhb
     * @param: @param
     *             list
     * @param: @param
     *             pageSize
     * @param: @return
     * @returnType:@param list 切割集合
     * @returnType:@param pageSize 分页长度
     * @returnType:@return List<List<T>> 返回分页数据
     */
     static public <T> List<List<T>> splitList(List<T> list, int pageSize) {
        int listSize = list.size();
        int page = (listSize + (pageSize - 1)) / pageSize;
        List<List<T>> listArray = new ArrayList<List<T>>();
        for (int i = 0; i < page; i++) {
            List<T> subList = new ArrayList<T>();
            for (int j = 0; j < listSize; j++) {
                int pageIndex = ((j + 1) + (pageSize - 1)) / pageSize;
                if (pageIndex == (i + 1)) {
                    subList.add(list.get(j));
                }
                if ((j + 1) == ((j + 1) * pageSize)) {
                    break;
                }
            }
            listArray.add(subList);
        }
        return listArray;
    }
}

集合分批切割

class UserSendThread implements Runnable {
    private List<UserEntity> listUser;
    public UserSendThread(List<UserEntity> listUser) {
        this.listUser=listUser;
    }
 
    @Override
    public void run() {
        for (UserEntity userEntity : listUser) {
            System.out.println(Thread.currentThread().getName()+","+userEntity.toString());
        }
        System.out.println();
    }
}
 
public class BatchSms {
 
    public static void main(String[] args) {
        // 1.初始化数据
        List<UserEntity> initUser = initUser();
        // 2.定义每个线程分批发送大小
        int userCount = 2;
        // 3.计算每个线需要分配跑的数据
        List<List<UserEntity>> splitList = ListUtils.splitList(initUser, userCount);
        for (int i = 0; i < splitList.size(); i++) {
            List<UserEntity> list = splitList.get(i);
            UserSendThread userSendThread = new UserSendThread(list);
            // 4.分配发送
            Thread thread = new Thread(userSendThread,"线程"+i);
            thread.start();
        }
 
    }
 
    static private List<UserEntity> initUser() {
        List<UserEntity> list = new ArrayList<UserEntity>();
        for (int i = 1; i <= 11; i++) {
            list.add(new UserEntity("userId:" + i, "userName:" + i));
        }
        return list;
    }
 
}

主方法

注意：以后再实际应用总不会这么做，一般使用MQ消息队列来进行推送，宝珠数据一致性，现在主要是为了理解多线程而使用。

　　　如果实现的线程过多，需要用线程池进行管理（后面会介绍）。