Java十分钟入门多线程中篇

目录

• 1、线程的调度：
• 1、设置优先级（Priority）：
• 2、休眠（sleep）
• 3、强制运行（join）
• 4、礼让（yield）
• 2、定时器线程：
• 3、线程的同步：

举例说明：

我们知道飞机在天上飞行是有固定的航线（可以理解成线程），每个机场都有最大的运行负载能力，当运行情况超过了负载能力的时候，这就需要塔台调度参与，会根据每架飞机的优先级排序。当在航线的时候，如果出现紧急情况，会让其他飞机避让，让这架飞机优先级提高，先降落。这就是调度，计算机程序线程运行也是这样的。

1、线程的调度：

在Java多线程中，主要可以通过下面四个方法来分配CPU的使用权：

• 设置优先级（Priority） 设置线程的优先级，值是1-10
• 休眠（sleep） 单位毫秒，让本线程属于阻塞状态，CPU会执行其他线程
• 强制运行（join） 让这个线程强制获取CPU资源来运行
• 礼让（yield） 暂停正在执行的线程，让其他线程先执行，执行完了在接着执行

1、设置优先级（Priority）：

有两个线程，分别设置最大优先级和最小优先级：

public class MyThread implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName()+"正在运行："+i);
        }
    }

    public static void main(String[] args) {
        Thread t1 = new Thread(new MyThread(),"线程A：");
        Thread t2 = new Thread(new MyThread(),"线程B***：");

        //设置优先级： 最高为10  最低为1
        t1.setPriority(Thread.MAX_PRIORITY);
        t2.setPriority(Thread.MIN_PRIORITY);

        //显示线程优先级：
        System.out.println("线程A的优先级是："+t1.getPriority());
        System.out.println("线程B的优先级是："+t2.getPriority());

        t1.start();
        t2.start();
    }
}

结果：

2、休眠（sleep）

Thread.sleep();--------单位是毫秒，让本线程属于阻塞状态，CPU会执行其他线程：

public class ThreadSleep {
    public static void main(String[] args) {
        sleepTime(5);
    }

    private static void sleepTime(int time) {
        for (int i = 0; i < 5; i++) {
            System.out.println("主线程执行了："+i+"s");
            try{
                //让线程休眠，进入阻塞状态
                Thread.sleep(1000); //休眠时间为1000毫秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

结果：

3、强制运行（join）

顾名思义，就是让某个线程强制进入执行：

子线程：

public class MyThread {
}

测试类：

public class Test {
    public static void main(String[] args) throws InterruptedException {

        Thread t1=  new Thread(new MyThread(),"我是子线程");
        t1.start();
        //当主线程执行任务1-10时，如果执行到5就让子线程t1强制进来执行，直到执行完了才让主线程继续执行任务
        for (int i = 0; i < 6; i++) {
            if (i==2){
                t1.join();
            }
            System.out.println(Thread.currentThread().getName()+"正在运行："+i);
        }
    }
}

结果：

4、礼让（yield）

暂停正在执行的线程，让其他线程先执行，执行完了在接着执行：

public class MyThread implements Runnable{

    //线程礼让，让本线线程阻塞，其他线程先执行
    //这里就是A线程运行二次后，礼让，让B 线程先执行
    //也是理论上的，就是不管怎么样第二次后面肯定让B先执行，但是后面就随机了
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName()+"正在运行："+i);
            if(i == 2){
                Thread.yield();
            }
        }
    }
}

测试类：

public class Test {
    public static void main(String[] args) {

        Thread t1 = new Thread(new MyThread(),"线程A:");
        Thread t2 = new Thread(new MyThread(),"----线程B");

        t1.start();
        t2.start();
    }
}

结果：

2、定时器线程：

定时器就是可以设置某个时间点来执行某个事件，比如系统每周删除依次日志文件，或者在指定的日期关闭系统，定时器本身就是一个线程任务来在指定的时候执行该任务。定时器是继承TimerTask来重写run方法，专门处理定时任务。

演示Demo:

public class MyThread extends TimerTask {

    @Override
    public void run() {
        //把任务定义在run方法中
        showMyself();
    }

    public void showMyself(){
        System.out.println("被Run方法执行的");
    }
}

测试类：

public class Test {
    public static void main(String[] args) {

        Timer timer = new Timer();

        //设置5秒后执行这个任务，并且每1秒重复执行这个任务

        timer.schedule(new MyThread(),5000,1000);

    }
}

结果：

3、线程的同步：

首先我们先看一个demo：

创建了两个线程对象，一个线程A任务用于执行print1,另一个线程B任务用于执行print2：

    public void print1(){
        System.out.print("中");
        System.out.println("国");
    }

    public void print2(){
        System.out.print("浙");
        System.out.println("江");
    }
}

测试类：

public class Test {
    public static void main(String[] args) {

        Printer p = new Printer();
        //A:
        new Thread(new Runnable() {
            @Override
            public void run() {
                while(true){
                    p.print1();
                }
            }
        },"线程A：").start();

        //B:
        new Thread("线程B："){
            @Override
            public void run(){
                while (true){
                    p.print2();
                }
            }
        }.start();
    }
}

这个程序就是当线程A执行的时候，输出中国，当B执行的时候，输出浙江，理论上是没有任何问题，但是我们看一下结果：

我们发现出问题了，其实这就是非线程同步（异步）：

• 同步：提交请求->等待服务器处理->处理完返回 这个期间客户端浏览器不能干任何事
• 异步：请求通过事件触发->服务器处理（这是浏览器仍然可以作其他事情）->处理完毕

其实非线程同步在有些系统是很危险的问题，比如12306，如果使用非线程同步，那么后果可想而知，那么该如何同步呢？ 这里介绍一个常用的方法，就是上锁：

如果两端代码(两个线程任务)是同步的，那么CPU同一时间只能执行一个任务,相当于给该线程上了一把锁， 在该线程没有执行完这段代码或者任务的时候，其他线程是不能占用CPU资源执行任务的。直到执行完了该线 程的代码，其他线程才可以执行。

更好的理解（举例）：

你去公共厕所上厕所（大的），当你进去后，需要把门关上并锁着，这就是上锁，为了保证你正常的结束（保证线程正常运行完），这期间其他人是不能进来的。

Synchronized 锁：

两个线程任务使用同一个对象为锁，那么两个线程方法是同步的 我们把上面的方法上个锁：

class Demo {
}

public class Printer {

   //创建任意一个对象，只要是对象相同就是锁相同，就是同步的！
    Demo d = new Demo();  

    public void print1(){
    	//当进入print1这个方法时，synchronized就给这个方法上了一个锁
        synchronized (d){
            System.out.print("中");
            System.out.println("国");
        }
    }

    public void print2(){
        //当进入print2这个方法时，synchronized也给这个方法上了一个锁
        synchronized (d){
            System.out.print("浙");
            System.out.println("江");
        }
    }

}

这样输出后就不会出现上面的那个问题，这里就不发结果截图啦。大家可以自己试一试，看看是否解决了这个问题~

我们还可以把锁直接定义在方法上，比如这样子：

    public static synchronized void print1(){
            System.out.print("中");
            System.out.println("国");
    }

如果是静态方法，上锁的方式是通过.class字节码对象：

    public static void print1() {
        synchronized (Printer.class) {
            System.out.print("中");
            System.out.println("国");
        }
    }

小结： 这篇文章主要介绍了线程的调度（四种）、线程的定时以及线程的同步，内容也不少，多线程是Java的一个难点，也没用一些华丽的图片来演示，在学习过程中会比较枯燥，包括我自己也是。大家也可以看看视频，加深理解和印象！

到此这篇关于Java十分钟入门多线程中篇的文章就介绍到这了,更多相关Java 多线程内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们！