多线程

这里主要是学习多线程的学习笔记，针对于刚刚学习线程的伙伴们。

概念

就是在同个操作系统中（window,MacOS,Linux）或者同个CPU（单核或者多核）中都可以同时运行多个任务(应用程序)互不影响。

例如：单核CPU中同时执行多个应用程序：就是相互交替执行，看起来像是同时执行一样。

多核CPU都在交替同时执行的。

每个任务都是一个进程，而每个任务又有自己的单个或多个子任务；而这些子任务就称作为线程。

进程和线程的关系：

• 一个进程可以包含一个或多个线程（当然最少是一个线程）。
• 线程是操作系统调度的最小任务单位
• 如何调度线程完全有操作系统来决定

多进程和多线程的区别

• 创建进程比创建线程开销大
• 进程间通信比线程间通信慢
• 多进程稳定性比多线程高（在多进程的情况下，一个进程的崩溃不会影响到其他的进程，而在多线程的情况下，一个线程的崩溃都会导致整个进程的崩溃）。

而一个java程序实际上是一个jvm进程，并且jvm用一个主线来执行main方法的，而在main方法中又可以启动多个线程。

多线程的编程的特点

• 多线程需要读些共享数据
• 多线程经常需要同步
• 多线程编程的复杂度高，调试更困难
• java中多线程编程：
  • 多线程模型是java程序最基本的并发模型
  • 网络，数据库，web等都依赖多线程模型

新建线程

步骤：创建一个线程对象，首先要启动一个线程如：

第一种：实例Thread
 

Thread newThread = new Thread();

newThread.start();

或extends Thread

从Thread派生，然后覆盖run方法，创建Mythread实例，然后start方法启动线程。

第二种：实现Runnable：只能调用start启动线程，run只是一个线程类中一个方法，不能直接调用。

Thread源码中可以看到start方法中调用了一个start0（）方法，而该方法的native指的是jvm虚拟器c代码实现的
public class Thread implments Runnable{

    public synchronized void start(){
         start0();
    }

private native void start0();
}

如下图所示：mian主线程和run子线程同时在执行

线程的优先级问题：

• 可以对线程设定优先级（Thread.setPriority(int n) //1~10）默认是5
• 优先级高德线程被操作系统调度的优先级高
• 不能通过设置优先级来确保功能的执行顺序

java用Thread对象表示一个线程，通过start启动线程。

一个线程对象只能调用一次start();

线程执行代码是run方法

线程调度由操作系统决定的，程序本身无法确定

sleep（）可以把当前线程暂停一段时间

线程的状态：

New(新建)   Runnable(运行中)   Blocked(被阻塞)   waiting(等待)  Timed Waiting(计时等待)  terminated(已终止)

线程终止的原因：

• run()方法执行到return语句返回（正常终止）
• 因为未捕获的异常导致线程终止（意外终止）
• 对某个线程的Thread实例调用stop强制终止

thread.Join();把指定的线程加入到当前线程，可以将两个交替执行的线程合并为顺序执行的线程。

比如在线程B中调用了线程A的Join()方法，直到线程A执行完毕后，才会继续执行线程B。

如下图所示：对t1加了join()方法，结果是t和t1结束才执行主线程

public class MyThread extends  Thread {

    String name;
    public MyThread(String name){
        this.name=name;
    }

    @Override
    public void run(){
        for (int i=0;i<3 ;i++){
            System.out.println("Hello,"+name+"!");
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] age) throws InterruptedException {
        Thread t = new MyThread("LIY");
        Thread t1 = new MyThread("LIYLLs");
        t.start();
        t1.start();
        t1.join();
        for (int i = 0; i < 3; i++) {
            System.out.println("main");
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

}
--------------------------------------------------

Hello,LIY!
Hello,LIYLLs!
Hello,LIYLLs!
Hello,LIY!
Hello,LIYLLs!
Hello,LIY!
main
main
main

中断线程：
第一种方法：通过函数interupt()方法，中断线程

public class HelloThread extends Thread{

    @Override
    public void run(){
        /**
         * isInterrupted检查线程是否被中断
         *
         * 如果线程处于等待状态，该线程会捕获InterruptedException
         * 捕获到InterruptedException说明其他线程对其调用interrupt()
         * 方法，通常情况下该线程应该立刻结束运行
         */

        while(!isInterrupted()){
            System.out.println("Hello");
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String [] arg) {
        Thread t = new HelloThread();
        t.start();
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        t.interrupt();//中端该线程
    }
}

第二种：通过定一个volatile的标志位的变量来控制，中断线程，如下代码

public class HelloThread_Volatile extends Thread{

    //volatile:确保线程能读取到更新后的变量值
    private volatile boolean flag=true;
    @Override
    public void run(){

        while(flag){
            System.out.println("Hello");
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String [] arg) {
        Thread t = new HelloThread_Volatile();
        t.start();
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        this.flag = false;
    }
}

volatile的特点：每次访问变量时，总是获取主内存的最新值，并且每次修改变量后，就立刻写到主内存中；当一个线程修改了共享变量的值，其他线程能够立刻访问到更改后的变量值。

 

 

 

转载于:https://my.oschina.net/youngit/blog/3061158