Java 多线程编程基础

Java 给多线程编程提供了内置的支持。 一条线程指的是进程中一个单一顺序的控制流,一个进程中可以并发多个线程，每条线程并行执行不同的任务 ; 多线程能满足程序员编写高效率的程序来达到充分利用 CPU 的目的。

什么是进程什么是线程呢？

  • 进程：正在运行/执行的一个程序 qq Safari
    进程用于管理所有的资源的，不进行实际的任务，由线程进行实际任务
    一个进程可有多个线程
  • 线程：完成具体任务 （多线程，多任务）
  • 例如：QQ运行起来 -> 进程 -> 多个进程 ： 1.视频 2.聊天 3.看qq空间 同时进行

什么是主线程，什么是子线程？

  • 主线程：Java (main方法里面的代码 就在主线程中运行）
    Android/iOS （启动程序 看到的UI界面 -> UI主线程）
  • 子线程：除了主线程之外的都是子线程
  • 主线程/子线程：都有自己独立的内存空间，占用不同的CPU资源。

线程是如何运行的？

  • 线程是通过抢占 时间片 来获取运行机会的 （谁抢到时间片，谁就可以运行）
    时间片是由操作系统来分配的 每一次的执行结果可能不一致. (分时操作系统）
    Thread
    获取当前线程信息： Thread.currentThread();
  • 当调用Start方法时，这个线程会自动扔到操作系统的队列任务中 （线程池），至于这个任务什么时候被执行，我们无法确定，由操作系统来确定

为什么要进行多线程编程

  • 1.防止主线程阻塞是进程崩溃
  • 2.充分利用CPU资源
  • 3.使进程（程序）能同时干更多的事情
  • 分配线程做其他耗费时间长的东西 （例如 某视频软件下载视频 不影响干其他的事）：
    在主线程里面 任务的执行顺序是从上至下的，如果一个任务要花费大量的时间（下载数据）
    这个任务后面的任务就会被阻塞，必须等这个原任务结束，后面的任务才能被执行·。这样用户体验不好，这个时候就需要将 耗时任务 放在另外一个不主线程里面的子线程执行

对于进程的描述已经差不多了 让我们进入代码阶段

一、如何开启一个线程

  • 两种方式：1.写一个类继承于Thread: 2.写一个类实现Runnable接口
1.Thread类的几个构造方法
public Thread(Runnable var1, String var2) 
public Thread(Thread var1, String var2);
1.使用Thread类开启线程

a.创建类继承Thread 重写父类的 run 方法 具体任务放在 run 里面
b.创建类的对象
c.调用 start方法() 开始执行系统会自动将这个任务放到队列中 等待调度

// 1.创建类继承于Thread
class TestThread extends Thread{
    private boolean isRun = true;
    public TestThread(String s) {
        super(s);
    }
    @Override
    public void run() {
        // 这个线程执行的任务放在这个 run 里面
        while (isRun){
            System.out.println("子线程");
        }
    }
    public void terminated(){
        isRun = false;
    }
}

public static void testThread(){
    System.out.println("main函数: "+ currentThread());
    // 2.创建子线程具体对象
    TestThread testThread = new TestThread("子线程1");
    TestThread testThread2 = new TestThread("子线程2");
    // 3.run 启动线程
    testThread.start();
    testThread2.start();
}

然后在main函数中调用 testThread()方法即可；
3.使用Runnable接口开启线程

a.创建一个类实现Runnable （这个类只是一个任务，并不能创建线程）
b.创建Thread类的对象 （Thread类可以创建线程 我们只需要将自己的任务和这个Thread关联）
c.调用一个Thread对象的 start() 方法

// 1.创建一个类实现Runnable接口
class TestRunnable implements Runnable{
    @Override
    public void run() {
        //这个线程执行的任务放在这个 run 里面
        for (int i = 0; i < 200; i++) {
            System.out.println(Thread.currentThread().getName()+ "-——>" + (i+1));
        }
    }
}

public static void testRunnable(){
    // 2.创建具体对象 -> 具体执行的任务
    // 这个类不能直接开启线程 必须依赖于Thread类
    TestRunnable testRunnable = new TestRunnable();
    // 3.创建一个Thread对象 让这个线程去执行 testRunnable 的任务 然后给上线程名字
    // public Thread(Runnable var1, String var2)  var1为实现 Runnable 接口的类  var2 为 线程名
    Thread thread = new Thread(testRunnable,"子线程1");
    Thread thread2 = new Thread(testRunnable, "子线程2");
    // 4.
    thread.start();
    thread2.start();
 }
然后在main函数中调用 testRunnable()方法即可；
4.两种方式的比较
  • 灵活性： 方式2 更好（更容易扩展） 方式1 已经继承Thread类 Java不能实现类的多继承
  • 共享行： 方式2 可以让类的成员变量数据共享 -> 三个乘客在一个售票口购票（案例）

二、线程的生命周期

  • 创建状态: new Thread();
  • 就绪状态: 1.新的线程调用 .start();
    2.阻塞条件结束
    3.正在运行的线程时间片被其他线程抢夺
  • 运行状态: 从就绪状态 到运行状态 是由操作系统来实现的 外部无法干预
  • 死亡状态: 1.run方法结束
    2.手动让线程暂停 不建议使用 stop() 通过其他方式让线程暂停

  • 阻塞状态：


    线程的生命周期.png

三、如何让一个线程结束

  • 1.不要直接调用stop()方法来结束一个线程
  • 2.自己写一个变量/标识 用来标识线程结束的临界点 
class TestThread extends Thread{
    自定义标识符 isRun
    private boolean isRun = true;
    public TestThread(String s) {
        super(s);
    }
    @Override
    public void run() {
        // 这个线程执行的任务放在这个 run 里面
        如果标识符改变 while循环结束
        while (isRun){
            System.out.println("子线程");
        }
    }
    如果要结束该线程 调用自定义terminated方法 让标识符改变
    public void terminated(){
        isRun = false;
    }
}

public static void myStop(){
    // 创建之前TestThread对象
    TestThread t = new TestThread("测试线程");
    System.out.println(t.getState());
    Thread thread = new Thread();
    t.start();

    for (int i = 0; i < 100; i++) {
        System.out.println("主线程：" + (i+1));
        if (i == 1){
            t.terminated();
        }
    }
}

四、线程的'礼让'与'插队'

1.礼让 yiead();
  • 线程礼让：礼让的线程会直接进入就绪状态，如果这个线程再次获得时间片 就会进行, 因此可能礼让失败；
public static void yield(){
    TestRunnable testRunnable = new TestRunnable();
    Thread t1 = new Thread(testRunnable, "奔驰");
    t1.start();

    如果主线程 输出到 20 则进行礼让 让其他线程线运行
    for (int i = 0; i < 20000; i++) {
        System.out.println("主线程"+(i+1));
        if (i > 20){
            Thread.yield();
        }
    }
}
2.插队 join();
  • 插队：让原来的线程阻塞 插队的线程运行完后, 原来的线程才运行
public static void join() throws InterruptedException {
    TestRunnable testRunnable = new TestRunnable();
    Thread t1 = new Thread(testRunnable, "奔驰");
    t1.start();

    for (int i = 0; i < 200; i++) {
        System.out.println("主线程"+(i+1));
        if (i > 10){
            // t1进行插队
            t1.join(); //当前线程阻塞
        }
    }
}

五、多线程的优缺点

  • 优点：充分利用CPU资源，执行效率搞，不会阻塞主线程。
  • 缺点：如果多个线程操作同一个资源时，有可能出现不安全
线程不安全举例

大家都买过车票，购票系统就是一个多线程任务，车票就是同一个资源；
买票的人那么多，肯对会出现同一个时刻购票，那为什么不会买到同一张座次的车票呢？
因为使用了某种手段保证线程安全，虽然在同一个时刻购票，但是不会影响到资源。

  • 下面我们用这个例子说说如何保证线程安全

六、如何保证线程安全

  • 1.Lock 锁
  • 2.synchronized 线程同步 修饰代码块 方法 必须保证锁的是同一个对象，每一个对象都维护一把锁（互斥锁）尽量让锁的地方变小 锁住重要的即可
  • 原理就是在线程开始运行时就给这个线程上锁，不让其他再调用开启这个线程，结束时再解锁就可以了
(一)Lock
class TicketWindow1 extends Thread{
    private static int total = 1000;
    // 创建静态Lock对象
    private static Lock lock = new ReentrantLock();

    public TicketWindow1(String s) {
        super(s);
    }

    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            // 调用lock() 加锁
            lock.lock();
            if (total > 0) {
                System.out.println("当前出票口" + getName() + "  票号为:" + total);
                total--;
            }
            // 运行完之后 调用unlock() 解锁
            lock.unlock();
        }
    }
}

这样同时运行两个线程 不会导致 total 出错 
public static void lock(){
    TicketWindow1 cq = new TicketWindow1("重庆");
    TicketWindow1 cd = new TicketWindow1("成都");
    cq.start();
    cd.start();
}
(五)synchronized
class TicketWindow2 extends Thread{
    private static int total = 1000;
    private static Object object = new Object();

    public TicketWindow2(String s) {
        super(s);
    }

    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            // buyTicket();
            synchronized (object) {
                buyTicket();
            }
        }
    }

    // 锁方法 -> 只能是第一个进来的对象来运行
    private synchronized void buyTicket(){
        if (total > 0) {
            System.out.println("当前出票口" + getName() + "  票号为:" + total);
            total--;
        }
    }
}
©著作权归作者所有,转载或内容合作请联系作者
平台声明：文章内容（如有图片或视频亦包括在内）由作者上传并发布，文章内容仅代表作者本人观点，简书系信息发布平台，仅提供信息存储服务。

推荐阅读更多精彩内容

  • Java多线程学习
    Java多线程学习 [-] 一扩展javalangThread类 二实现javalangRunnable接口 三T...
    影驰阅读 8,064评论 1赞 18
  • java多线程
    本文主要讲了java中多线程的使用方法、线程同步、线程数据传递、线程状态及相应的一些线程函数用法、概述等。 首先讲...
    李欣阳阅读 7,186评论 1赞 15
  • java多线程编程基础三-线程协作
    wait/notify（通知与唤醒） Object.wait()/Object.wait(long)：是执行线程暂...
    凌晨四点半_94ef阅读 1,469评论 0赞 1
  • java多线程编程基础一
    java多线程的实现方式： 实现runnable接口 继承thread类 java程序运行的方式： 串行 并行 并...
    凌晨四点半_94ef阅读 780评论 0赞 2
  • Java基础17-多线程
    概述 本文主要讲java中多线程的使用方法、线程同步、线程数据传递、线程状态及相应的线程函数用法等。首先让我们来了...
    Tian_Peng阅读 2,548评论 0赞 0