Java入门系列-21-多线程

时间  2019-12-08
标签 java 入门 系列 多线程 栏目 Java 繁體版
原文   原文链接

什么是线程

在操做系统中，一个应用程序的执行实例就是进程，进程有独立的内存空间和系统资源，在任务管理器中能够看到进程。java

线程是CPU调度和分派的基本单位，也是进程中执行运算的最小单位，可完成一个独立的顺序控制流程，固然一个进程中能够有多个线程。编程

多线程：一个进程中同时运行了多个线程，每一个线程用来完成不一样的工做。多个线程交替占用CPU资源，并不是真正的并行执行。多线程

使用多线程能充分利用CPU的资源，简化编程模型，带来良好的用户体验。ide

一个进程启动后拥有一个主线程，主线程用于产生其余子线程，并且主线程必须最后完成执行，它执行各类关闭动做。测试

在Java中main()方法为主线程入口，下面使用 Thread 类查看主线程名。this

public class MainThread {
    public static void main(String[] args) {
        //获取当前线程
        Thread t=Thread.currentThread();
        System.out.println("当前线程名字："+t.getName());
        //自定义线程名字
        t.setName("MyThread");
        System.out.println("当前线程名字："+t.getName());
    }
}

建立线程

在Java中建立线程有两种方式
1.继承 java.lang.Thread 类
2.实现 java.lang.Runnable 接口操作系统

1.继承 Thread 类建立线程

(1)定义MyThread类继承Thread类线程

(2)重写run()方法，编写线程执行体code

public class MyThread extends Thread{

    //重写run方法
    @Override
    public void run() {
        for (int i = 1; i <= 10; i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}

(3)建立线程对象，调用start()方法启动线程对象

public class TestMyThread {

    public static void main(String[] args) {
        MyThread myThread=new MyThread();
        //启动线程
        myThread.start();
    }
}

多个线程同时启动后是交替执行的，线程每次执行时长由分配的CPU时间片长度决定

修改 TestMyThread.java 观察多线程交替执行

public class TestMyThread {

    public static void main(String[] args) {
        MyThread myThread1=new MyThread();
        MyThread myThread2=new MyThread();
        myThread1.start();
        myThread2.start();
    }
}

多运行几回观察效果

启动线程可否直接调用 run()方法？
不能，调用run()方法只会是主线程执行。调用start()方法后，子线程执行run()方法，主线程和子线程并行交替执行。

2.实现 Runnable 接口建立线程

(1)定义MyRunnable类实现Runnable接口

(2)实现run()方法，编写线程执行体

public class MyRunnable implements Runnable{
    //实现 run方法
    @Override
    public void run() {
        for (int i = 1; i <= 10; i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}

(3)建立线程对象，调用start()方法启动线程

public class TestMyRunnable {

    public static void main(String[] args) {
        Runnable runnable=new MyRunnable();
        //建立线程，传入runnable
        Thread t=new Thread(runnable);
        t.start();
    }
}

线程的生命周期

建立状态：线程建立完成，好比 MyThread thread=new MyThread

就绪状态：线程对象调用 start() 方法，线程会等待CPU分配执行时间，并无立马执行

运行状态：线程分配到了执行时间，进入运行状态。线程在运行中发生礼让 (yield) 会回到就绪状态

阻塞状态：执行过程当中遇到IO操做或代码 Thread.sleep()，阻塞后的线程不能直接回到运行状态，须要从新进入就绪状态等待资源的分配。

死亡状态：天然执行完毕或外部干涉终止线程

线程调度

线程调度指按照特定机制为多个线程分配CPU的使用权

线程调度经常使用方法

方法 说明
setPriority(int newPriority) 更改线程的优先级
static void sleep(long millis) 在指定的毫秒数内让当前正在执行的线程休眠
void join() 等待该线程终止
static void yield() 暂停当前正在执行的线程对象，并执行其余线程
void interrupt() 中断线程
boolean isAlive() 测试线程是否处于活动状态

线程优先级的设置

线程优先级由1~10表示，1最低，默认有限级为5。优先级高的线程得到CPU资源的几率较大。

public class TestPriority {

    public static void main(String[] args) {
        Thread t1=new Thread(new MyRunnable(),"线程A");
        Thread t2=new Thread(new MyRunnable(),"线程B");
        //最大优先级
        t1.setPriority(Thread.MAX_PRIORITY);
        //最小优先级
        t2.setPriority(Thread.MIN_PRIORITY);
        t1.start();
        t2.start();
    }
}

线程休眠

让线程暂时睡眠指定时长，线程进入阻塞状态，睡眠时间事后线程会再进入可运行状态。

休眠时长以毫秒为单位，调用sleep()方法须要处理 InterruptedException异常。

public class TestSleep {
    
    public static void main(String[] args) {
        for (int i = 1; i <= 10; i++) {
            System.out.println("第 "+i+" 秒");
            try {
                //让当前线程休眠1秒
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

强制运行

使用 join() 方法实现，能够认为是线程的插队，会先强制执行插队的线程。

public class JoinThread implements Runnable{

    @Override
    public void run() {
        for (int i = 1; i <=10; i++) {
            System.out.println("线程名："+Thread.currentThread().getName()+" i:"+i);
        }
        System.out.println("插队线程执行完毕！");
    }   
}
public class TestJoin {

    public static void main(String[] args) {
        Thread joinThread=new Thread(new JoinThread(),"插队的线程");
        //启动后与主线程交替执行
        joinThread.start();
        for (int i = 1; i <= 10; i++) {
            if (i==5) {
                try {
                    System.out.println("====开始插队强制执行====");
                    joinThread.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("线程名："+Thread.currentThread().getName()+" i:"+i);
        }
        System.out.println("主线程执行完毕！");
    }
}

最一开始执行，主线程 main 和 "插队的线程"是交替执行。当主线程的循环到第5次的时候，调用 "插队的线程"的join方法，开始强制执行"插队的线程"，待"插队的线程"执行完后，才继续恢复 main 线程的循环。

线程礼让

使用 yield() 方法实现，礼让后会暂停当前线程，转为就绪状态，其余具备相同优先级的线程得到运行机会。

下面咱们实现Runnable接口，在run方法中实现礼让，建立两个线程，达到某种条件时礼让。

public class YieldThread implements Runnable{

    @Override
    public void run() {
        for (int i = 1; i <= 10; i++) {
            System.out.println("线程名："+Thread.currentThread().getName()+" i:"+i);
            //当前线程执行到5后发生礼让
            if (i==5) {
                System.out.println(Thread.currentThread().getName()+" 礼让：");
                Thread.yield();
            }
        }
    }
}
public class TestYield {

    public static void main(String[] args) {
        Thread t1=new Thread(new YieldThread(),"A");
        Thread t2=new Thread(new YieldThread(),"B");
        t1.start();
        t2.start();
    }
}

只是提供一种可能，不能保证必定会实现礼让

线程同步

首先看一个多线共享同一个资源引起的问题

仓库有10个苹果，小明、小红、小亮每次能够从仓库中拿1个苹果，拿完苹果后仓库中的苹果数量-1。

先编写仓库资源类，实现接口

//这个实现类将被多个线程对象共享
public class ResourceThread implements Runnable{
    private int num=10;
    @Override
    public void run() {
        while(true) {
            if (num<=0) {
                break;
            }
            num--;
            try {
                Thread.sleep(300);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"拿走一个，还剩余："+num);
        }
    }
}

编写测试类，建立两个线程对象，共享同一个资源

public class TestResource {

    public static void main(String[] args) {
        ResourceThread resource=new ResourceThread();
        //使用同一个Runnable实现类对象
        Thread t1=new Thread(resource,"小明");
        Thread t2=new Thread(resource,"小红");
        Thread t3=new Thread(resource,"小亮");
        t1.start();
        t2.start();
        t3.start();
    }
}

运行后咱们发现，每次拿完苹果后的剩余数量出现了问题，使用同步方法能够解决这个问题。

语法：

访问修饰符 synchronized 返回类型 方法名(参数列表){
    ……
}

synchronized 就是为当前的线程声明一个锁

修改 ResourceThread.java 实现同步

//这个实现类将被多个线程对象共享
public class ResourceThread implements Runnable{
    private int num=10;
    private boolean isHave=true;
    @Override
    public void run() {
        while(isHave) {
            take();
        }
    }
    //同步方法
    public synchronized void take() {
        if (num<=0) {
            isHave=false;
            return;
        }
        num--;
        try {
            Thread.sleep(300);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"拿走一个，还剩余："+num);
    }
}

实现同步的第二种方式同步代码块

语法：

synchronized(syncObject){
    //须要同步的代码
}

syncObject为需同步的对象，一般为this

修改 ResourceThread.java 改成同步代码块

//这个实现类将被多个线程对象共享
public class ResourceThread implements Runnable{
    private int num=10;
    private boolean isHave=true;
    @Override
    public void run() {
        while(isHave) {
            synchronized(this) {
                if (num<=0) {
                    isHave=false;
                    return;
                }
                num--;
                try {
                    Thread.sleep(300);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"拿走一个，还剩余："+num);               
            }
        }
    }
}
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程