Java中级/线程

最新推荐文章于 2024-07-12 15:51:39 发布

fan__lee

最新推荐文章于 2024-07-12 15:51:39 发布

阅读量227

点赞数

分类专栏： java 文章标签：多线程 java

本文链接：https://blog.csdn.net/fan__lee/article/details/108689563

版权

java 专栏收录该内容

23 篇文章 0 订阅

订阅专栏

文章目录

启动一个线程

多线程即在同一时间，可以做多件事情。
创建多线程有3种方式，分别是继承线程类,实现Runnable接口,匿名类

线程概念

首先要理解进程(Processor)和线程(Thread)的区别
进程：启动一个LOL.exe就叫一个进程。接着又启动一个DOTA.exe，这叫两个进程。
线程：线程是在进程内部同时做的事情，比如在LOL里，有很多事情要同时做，比如"盖伦” 击杀“提莫”，同时“赏金猎人”又在击杀“盲僧”，这就是由多线程来实现的。
在不使用线程时：
只有在盖伦杀掉提莫后，赏金猎人才开始杀盲僧：
Hero.java

package jincheng;
import java.io.Serializable;

public class Hero {
    public String name;
    public float hp;
     
    public int damage;
     
    public void attackHero(Hero h) {
        try {
            //为了表示攻击需要时间，每次攻击暂停1000毫秒
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        h.hp-=damage;
        System.out.format("%s 正在攻击 %s, %s的血变成了 %.0f%n",name,h.name,h.name,h.hp);
         
        if(h.isDead())
            System.out.println(h.name +"死了！");
    }
 
    public boolean isDead() {
        return 0>=hp?true:false;
    }
}

TestThread.java

package jincheng;


public class TestThread {
	public static void main(String[] args){
		Hero garteen = new Hero();
		garteen.name = "盖伦";
		garteen.hp = 616;
		garteen.damage = 100;
		
        Hero teemo = new Hero();
        teemo.name = "提莫";
        teemo.hp = 300;
        teemo.damage = 100;
         
        Hero bh = new Hero();
        bh.name = "赏金猎人";
        bh.hp = 500;
        bh.damage = 100;
         
        Hero leesin = new Hero();
        leesin.name = "盲僧";
        leesin.hp = 455;
        leesin.damage = 100;
        
        while(!teemo.isDead()){//血量小于等于0时，循环结束，不再攻击
        	bh.attackHero(teemo);
        }
        
        //赏金猎人攻击盲僧
        while(!leesin.isDead()){
            bh.attackHero(leesin);
        }			
	}
}

输出：
赏金猎人 正在攻击 提莫, 提莫的血变成了 200
赏金猎人 正在攻击 提莫, 提莫的血变成了 100
赏金猎人 正在攻击 提莫, 提莫的血变成了 0
提莫死了！
赏金猎人 正在攻击 盲僧, 盲僧的血变成了 355
赏金猎人 正在攻击 盲僧, 盲僧的血变成了 255
赏金猎人 正在攻击 盲僧, 盲僧的血变成了 155
赏金猎人 正在攻击 盲僧, 盲僧的血变成了 55
赏金猎人 正在攻击 盲僧, 盲僧的血变成了 -45
盲僧死了！

创建多线程-继承线程类

使用多线程，就可以做到盖伦在攻击提莫的同时，赏金猎人也在攻击盲僧
设计一个类KillThread 继承Thread，并且重写run方法
启动线程办法： 实例化一个KillThread对象，并且调用其start方法
就可以观察到赏金猎人攻击盲僧的同时，盖伦也在攻击提莫

package jincheng;

public class KillThread extends Thread{
    private Hero h1;
    private Hero h2;
 
    public KillThread(Hero h1, Hero h2){
        this.h1 = h1;
        this.h2 = h2;
    }
    public void run(){//提前写好run方法
    	while(!h2.isDead()){
    		h1.attackHero(h2);
    	}
    }
}

'TestThread后面变为：'
        KillThread killThread1 = new KillThread(gareen,teemo);
        killThread1.start();//需要有已经写好的run方法
        KillThread killThread2 = new KillThread(bh,leesin);
        killThread2.start();
'执行结果：'
盖伦 正在攻击 提莫, 提莫的血变成了 200
赏金猎人 正在攻击 盲僧, 盲僧的血变成了 255
盖伦 正在攻击 提莫, 提莫的血变成了 100
盖伦 正在攻击 提莫, 提莫的血变成了 0
赏金猎人 正在攻击 盲僧, 盲僧的血变成了 155
提莫死了！
赏金猎人 正在攻击 盲僧, 盲僧的血变成了 55
赏金猎人 正在攻击 盲僧, 盲僧的血变成了 -45
盲僧死了！

创建多线程-实现Runnable接口

创建类Battle，实现Runnable接口
启动的时候，首先创建一个Battle对象，然后再根据该battle对象创建一个线程对象，并启动：

Battle battle1 = new Battle(gareen,teemo);
new Thread(battle1).start();

battle1 对象实现了Runnable接口，所以有run方法，但是直接调用run方法，并不会启动一个新的线程。
必须，借助一个线程对象的start()方法，才会启动一个新的线程。
所以，在创建Thread对象的时候，把battle1作为构造方法的参数传递进去，这个线程启动的时候，就会去执行battle1.run()方法了。

'与killThread不同，killThread继承了Thread类，而battel实现'
'了Runnable接口，无法直接调用start方法，需要通过创建Thread进程，然后调用start方法'
package jincheng;
public class Battle implements Runnable{
    private Hero h1;
    private Hero h2;
 
    public Battle(Hero h1, Hero h2){
        this.h1 = h1;
        this.h2 = h2;
    }
 
    public void run(){
        while(!h2.isDead()){
            h1.attackHero(h2);
        }
    }
}

'TestThread后面变为：'
        Battle battle1 = new Battle(gareen,teemo);
         
        new Thread(battle1).start();
 
        Battle battle2 = new Battle(bh,leesin);
        new Thread(battle2).start();

创建多线程-匿名类

使用匿名类，继承Thread,重写run方法，直接在run方法中写业务代码
匿名类的一个好处是可以很方便的访问外部的局部变量。
前提是外部的局部变量需要被声明为final。(JDK7以后就不需要了)

        //匿名类
        Thread t1= new Thread(){
            public void run(){
                //匿名类中用到外部的局部变量teemo，必须把teemo声明为final
                //但是在JDK7以后，就不是必须加final的了
                while(!teemo.isDead()){
                    gareen.attackHero(teemo);
                }              
            }
        };       
        t1.start();      
        Thread t2= new Thread(){
            public void run(){
                while(!leesin.isDead()){
                    bh.attackHero(leesin);
                }              
            }
        };
        t2.start();

创建多线程的三种方式

把上述3种方式再整理一下：

继承Thread类
实现Runnable接口
匿名类的方式
注：启动线程是start()方法，run()并不能启动一个新的线程

把练习-查找文件内容改为多线程查找文件内容

原练习的思路是遍历所有文件，当遍历到文件是 .java的时候，查找这个文件的内容，查找完毕之后，再遍历下一个文件
现在通过多线程调整这个思路：
遍历所有文件，当遍历到文件是.java的时候，创建一个线程去查找这个文件的内容，不必等待这个线程结束，继续遍历下一个文件

常见的线程方法

在这里插入图片描述

当前线程暂停

Thread.sleep(1000); 表示当前线程暂停1000毫秒，其他线程不受影响
Thread.sleep(1000); 会抛出InterruptedException 中断异常，因为当前线程sleep的时候，有可能被停止，这时就会抛出 InterruptedException

package multiplethread;
 
public class TestThread {
 
    public static void main(String[] args) {
         
        Thread t1= new Thread(){
            public void run(){
                int seconds =0;
                while(true){
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    System.out.printf("已经玩了LOL %d 秒%n", seconds++);
                }              
            }
        };
        t1.start();  
    }
}

加入到当前线程中

首先解释一下主线程的概念
所有进程，至少会有一个线程即主线程，即main方法开始执行，就会有一个看不见的主线程存在。
在42行执行t.join，即表明在主线程中加入该线程。主线程会等待该线程结束完毕，才会往下运行。

package multiplethread;
  
import charactor.Hero;
  
public class TestThread {
  
    public static void main(String[] args) {
          
        final Hero gareen = new Hero();
        gareen.name = "盖伦";
        gareen.hp = 616;
        gareen.damage = 50;
  
        final Hero teemo = new Hero();
        teemo.name = "提莫";
        teemo.hp = 300;
        teemo.damage = 30;
          
        final Hero bh = new Hero();
        bh.name = "赏金猎人";
        bh.hp = 500;
        bh.damage = 65;
          
        final Hero leesin = new Hero();
        leesin.name = "盲僧";
        leesin.hp = 455;
        leesin.damage = 80;
          
        Thread t1= new Thread(){
            public void run(){
                while(!teemo.isDead()){
                    gareen.attackHero(teemo);
                }              
            }
        };//匿名类结束要加分号
          
        t1.start();
 
        //代码执行到这里，一直是main线程在运行
        try {
            //t1线程加入到main线程中来，只有t1线程运行结束，才会继续往下走
            t1.join();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
 
        Thread t2= new Thread(){
            public void run(){
                while(!leesin.isDead()){
                    bh.attackHero(leesin);
                }              
            }
        };
        //会观察到盖伦把提莫杀掉后，才运行t2线程
        t2.start();     
    }   
}

// t1.start必须要放在t1.join前，如果写成下面的样子，运行还是多线程交互运行：

	        try {
	            t1.join();  
	        } catch (InterruptedException e) {
	            // TODO Auto-generated catch block
	            e.printStackTrace();
	        }
	        t1.start();
	        t2.start();
'结果：'
赏金猎人 正在攻击 盲僧, 盲僧的血变成了 195
盖伦 正在攻击 提莫, 提莫的血变成了 100
赏金猎人 正在攻击 盲僧, 盲僧的血变成了 130
盖伦 正在攻击 提莫, 提莫的血变成了 50
.....

线程优先级

当线程处于竞争关系的时候，优先级高的线程会有更大的几率获得CPU资源为了演示该效果，要把暂停时间去掉，多条线程各自会尽力去占有CPU资源
同时把英雄的血量增加100倍，攻击减低到1，才有足够的时间观察到优先级的演示

结果如图：
在这里插入图片描述
如图可见，线程1的优先级是MAX_PRIORITY，所以它争取到了更多的CPU资源执行代码
Hero.java中attackHero方法中间变为：

    public void attackHero(Hero h) {
        //把暂停时间去掉，多条线程各自会尽力去占有CPU资源
        //线程的优先级效果才可以看得出来
//        try {
//           
//            Thread.sleep(0);
//        } catch (InterruptedException e) {
//            // TODO Auto-generated catch block
//            e.printStackTrace();
//        }
        h.hp-=damage;
        System.out.format("%s 正在攻击 %s, %s的血变成了 %.0f%n",name,h.name,h.name,h.hp);

package multiplethread;
  
import charactor.Hero;
  
public class TestThread {
  
    public static void main(String[] args) {
          
        final Hero gareen = new Hero();
        gareen.name = "盖伦";
        gareen.hp = 6160;
        gareen.damage = 1;
  
        final Hero teemo = new Hero();
        teemo.name = "提莫";
        teemo.hp = 3000;
        teemo.damage = 1;
          
        final Hero bh = new Hero();
        bh.name = "赏金猎人";
        bh.hp = 5000;
        bh.damage = 1;
          
        final Hero leesin = new Hero();
        leesin.name = "盲僧";
        leesin.hp = 4505;
        leesin.damage = 1;
          
        Thread t1= new Thread(){
            public void run(){
 
                while(!teemo.isDead()){
                    gareen.attackHero(teemo);
                }              
            }
        };
          
        Thread t2= new Thread(){
            public void run(){
                while(!leesin.isDead()){
                    bh.attackHero(leesin);
                }              
            }
        };
         
        t1.setPriority(Thread.MAX_PRIORITY);
        t2.setPriority(Thread.MIN_PRIORITY);
        t1.start();
        t2.start();      
    }  
}

临时暂停

当前线程，临时暂停，使得其他线程可以有更多的机会占用CPU资源 Thread.yield();

package multiplethread;
  
import charactor.Hero;
  
public class TestThread {
  
    public static void main(String[] args) {
          
        final Hero gareen = new Hero();
        gareen.name = "盖伦";
        gareen.hp = 61600;
        gareen.damage = 1;
  
        final Hero teemo = new Hero();
        teemo.name = "提莫";
        teemo.hp = 30000;
        teemo.damage = 1;
          
        final Hero bh = new Hero();
        bh.name = "赏金猎人";
        bh.hp = 50000;
        bh.damage = 1;
          
        final Hero leesin = new Hero();
        leesin.name = "盲僧";
        leesin.hp = 45050;
        leesin.damage = 1;
          
        Thread t1= new Thread(){
            public void run(){
 
                while(!teemo.isDead()){
                    gareen.attackHero(teemo);
                }              
            }
        };
          
        Thread t2= new Thread(){
            public void run(){
                while(!leesin.isDead()){
                    //临时暂停，使得t1可以占用CPU资源
                    Thread.yield();
                     
                    bh.attackHero(leesin);
                }              
            }
        };
         
        t1.setPriority(5);
        t2.setPriority(5);
        t1.start();
        t2.start();         
    }    
}

守护线程

守护线程的概念是： 当一个进程里，所有的线程都是守护线程的时候，结束当前进程。
就好像一个公司有销售部，生产部这些和业务挂钩的部门。
除此之外，还有后勤，行政等这些支持部门。
如果一家公司销售部，生产部都解散了，那么只剩下后勤和行政，那么这家公司也可以解散了。
守护线程就相当于那些支持部门，如果一个进程只剩下守护线程，那么进程就会自动结束。
守护线程通常会被用来做日志，性能统计等工作。

package multiplethread;
  
public class TestThread {
  
    public static void main(String[] args) {
          
        Thread t1= new Thread(){
            public void run(){
                int seconds =0;
                 
                while(true){
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    System.out.printf("已经玩了LOL %d 秒%n", seconds++);
                     
                }              
            }
        };
        t1.setDaemon(true);
        t1.start();         
    }     
}

练习-英雄充能

英雄有可以放一个技能叫做: 波动拳-a du gen。
每隔一秒钟，可以发一次，但是只能连续发3次。
发完3次之后，需要充能5秒钟，充满，再继续发。

'Hero.java中代码：'
    public  int seconds =1;
    private int count = 1;
	public void a_du_gen(int j) {
		// TODO Auto-generated method stub
        while(count<=j){
            try {
            	if(seconds<=3){
            		Thread.sleep(1000);
            		System.out.printf("波动拳第%d发%n", seconds++);
            	}else{
            		seconds=1;
            		System.out.println("开始为时5秒的充能");
            		Thread.sleep(5000);
            		count++;
            	}       
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }      
        }

'Test'
	        Thread t1 = new Thread(){
	        	public void run(){
	        		gareen.a_du_gen(2);
	        	}
	        };
	          t1.start();

练习-破解密码

生成一个长度是3的随机字符串，把这个字符串当作密码
创建一个破解线程，使用穷举法，匹配这个密码
创建一个日志线程，打印都用过哪些字符串去匹配，这个日志线程设计为守护线程
提示：破解线程把穷举法生成的可能密码放在一个容器中，日志线程不断的从这个容器中拿出可能密码，并打印出来。如果发现容器是空的，就休息1秒，如果发现不是空的，就不停的取出，并打印。

同步

多线程的同步问题指的是多个线程同时修改一个数据的时候，可能导致的问题
多线程的问题，又叫Concurrency 问题

演示同步问题

假设盖伦有10000滴血，并且在基地里，同时又被对方多个英雄攻击就是有多个线程在减少盖伦的hp 同时又有多个线程在恢复盖伦的hp
假设线程的数量是一样的，并且每次改变的值都是1，那么所有线程结束后，盖伦应该还是10000滴血。但是。。。

注意：不是每一次运行都会看到错误的数据产生，多运行几次，或者增加运行的次数

package jincheng;

public class Hero1 {
    public String name;
    public float hp;
    public int damage;	
    
	public void recover(){
		hp -= 1;
	}
	public void hurt(){
		hp += 1;
	}
}

/**
*文档注释 
* @author x、
*/
package jincheng;

import java.util.Arrays;
public class test {
	public static void main(String[] args){
        
    final Hero1 gareen = new Hero1();
    gareen.name = "盖伦";
    gareen.hp = 10000;
       
    System.out.printf("盖伦的初始血量是 %.0f%n", gareen.hp);
       
    //多线程同步问题指的是多个线程同时修改一个数据的时候，导致的问题
       
    //假设盖伦有10000滴血，并且在基地里，同时又被对方多个英雄攻击
       
    //用JAVA代码来表示，就是有多个线程在减少盖伦的hp
    //同时又有多个线程在恢复盖伦的hp
       
    //n个线程增加盖伦的hp
       
    int n = 10000;

    Thread[] addThreads = new Thread[n];
    Thread[] reduceThreads = new Thread[n];
       
    for (int i = 0; i < n; i++) {
        Thread t = new Thread(){
            public void run(){
                gareen.recover();
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        };
        t.start();
        addThreads[i] = t;
           
    }
       
    //n个线程减少盖伦的hp
    for (int i = 0; i < n; i++) {
        Thread t = new Thread(){
            public void run(){
                gareen.hurt();
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        };
        t.start();
        reduceThreads[i] = t;
    }
       
    //等待所有增加线程结束
    for (Thread t : addThreads) {
        try {
            t.join();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    //等待所有减少线程结束
    for (Thread t : reduceThreads) {
        try {
            t.join();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
       
    //代码执行到这里，所有增加和减少线程都结束了
       
    //增加和减少线程的数量是一样的，每次都增加，减少1.
    //那么所有线程都结束后，盖伦的hp应该还是初始值
       
    //但是事实上观察到的是：
               
    System.out.printf("%d个增加线程和%d个减少线程结束后%n盖伦的血量变成了 %.0f%n", n,n,gareen.hp);
       
}
}
'输出：'
盖伦的初始血量是 10000
10000个增加线程和10000个减少线程结束后
盖伦的血量变成了 9999

分析同步问题产生的原因

假设增加线程先进入，得到的hp是10000
进行增加运算
正在做增加运算的时候，还没有来得及修改hp的值，减少线程来了
减少线程得到的hp的值也是10000
减少线程进行减少运算
增加线程运算结束，得到值10001，并把这个值赋予hp
减少线程也运算结束，得到值9999，并把这个值赋予hp hp，最后的值就是9999 虽然经历了两个线程各自增减了一次，本来期望还是原值10000，但是却得到了一个9999
这个时候的值9999是一个错误的值，在业务上又叫做脏数据

在这里插入图片描述

解决思路

总体解决思路是：在增加线程访问hp期间，其他线程不可以访问hp

增加线程获取到hp的值，并进行运算
在运算期间，减少线程试图来获取hp的值，但是不被允许
增加线程运算结束，并成功修改hp的值为10001
减少线程，在增加线程做完后，才能访问hp的值，即10001
减少线程运算，并得到新的值10000

fan__lee

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java中级/线程

文章目录启动一个线程线程概念创建多线程-继承线程类创建多线程-实现Runnable接口创建多线程-匿名类创建多线程的三种方式顶折纠问启动一个线程多线程即在同一时间，可以做多件事情。创建多线程有3种方式，分别是继承线程类,实现Runnable接口,匿名类线程概念首先要理解进程(Processor)和线程(Thread)的区别进程：启动一个LOL.exe就叫一个进程。接着又启动一个DOTA.exe，这叫两个进程。线程：线程是在进程内部同时做的事情，比如在LOL里，有很多事情要同时做，比如"盖伦”
复制链接

扫一扫