Java十分钟入门多线程中篇

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.printhttp://("中");

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的一个难点，也没用一些华丽的图片来演示，在学习过程中会比较枯燥，包括我自己也是。大家也可以看看视频，加深理解和印象！

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。