线程

Posted gfl-1112

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了线程相关的知识,希望对你有一定的参考价值。

线程安全:StringBuilder非线程 StringBuffer线程 /  Vector线程 ArrayList非线程 /  快速迭代时不能有其他线程进行操作

进程:操作系统结构的基础:是一个正在执行的程序,计算机中正在运行的程序实例

线程:线程(thread)是进程中某个单一顺序的控制流,是程序运行的基本执行单元,任何一个程序中至少需要一个主线程

 

线程优缺点:
优点:程序执行思路步骤清晰,步骤分明
缺点:一次只能做一件事情,必须做完意见事后才能继续做另一件事

 

可以使用线程让多条业务逻辑同时处理成为可能!
使用线程的好处:异步处理,简化编程模型,提高CPU使用

 

线程同步:只有单一的线程,按照既定的程序流依次执行代码

线程异步:多个线程同时执行代码

 

线程的创建两种方式:

继承Thread类  :public class MyThread extends Thread{}

实现Runnable接口 :public class MyThread implements Runnable(){}

两种方法都要重写run方法,该方法是线程的核心方法,用于封装线程要处理的业务内容

run方法是线程类中最重要的方法,该线程中所有需要单独执行的业务逻辑都需在run方法中运行

public class MyThread extends Thread{
    public void run(){
        //线程执行的内容
    }
}

 

两种方法的区别:
继承自thread类是得到真正的一个线程对象,可以通过start方法开启线程
实现runnable接口,仅仅是将线程中要实现逻辑进行了抽离,同时也便于多线程的并发处理。

 

启用线程:使用start()方法启动线程

线性远程:run()方法不需要我们自己调用,当调用start()方法时将自动调用run方法,直到run方法执行完毕或人为停止或挂起

多线程的创建步骤: 建立多个类继承Thread类或实现Runnable接口

                                 实现run方法

                                 实例化线程类并调用start方法

 

如果要多个线程实现同样的功能:
1.写一个runnable中,封装至不同的线程中(这种方式更方便)
2.继承thread,多次new可以实现相同功能(这种方式不方便,但是线程内容不同的时候这种方法更方便)

 

线程的生命周期:线程和人一样也会生老病死经理各个阶段

主要经历如下阶段
  准备就绪:  new
  运行时 :  runnable   //调用start后
  阻塞等待:   wait   (blocked   timed_waiting    waiting)
  终止完成:  terminated

获取线程的当前状态:     getState()
判断线程的状态:        isAlive()

获得线程的名称:  getName()

控制线程的主要方法
  start() 启动线程
  stop() 终止当前线程 (过时方法)
  suspend() 挂起线程
  resume() 继续挂起的线程
  join() 等待线程执行完毕
  yield() 暂缓线程
  sleep() 线程等待
  wait() 线程等待
  notify() 唤醒线程

技术图片

yeild、 join、suspend、sleep、wait等方法的调用,都可是程序进入阻塞等待状态,若一致处于阻塞状态,则成为线程死锁
线程死锁:线程处于阻塞状态后无法恢复,该情形成为线程死锁(会导致程序无法继续进行,所以所有处于阻塞状态的线程最后都应恢复运行,恢复后继续进入运行时状态)

例子:编写两个线程,并在各自线程中打印1-10的数值,观察结果

通过继承获得的线程

/**
 * 自定义线程,通过继承
 */
public class MyThread1 extends Thread{//继承中有很多方法
    /**
     * 构造方法
     * 传入线程的名称
     * @param threadName
     */
    public MyThread1(String threadName){
        super(threadName);
     //构造方法中的状态是new,等待就绪
//获取线程的状态 new System.out.println(this.getState()); //判断线程是否存活 false,只有调用了start之后才会为true System.out.println(this.isAlive()); }
@Override
   //都要对run方法进行重写
public void run() { //获得线程的名称 System.out.println("当前线程:"+getName()); System.out.println(this.getState()); System.out.println(this.isAlive());
     //循环打印
for(int i = 1; i <= 10; i++){ System.out.println("线程A:"+i); } } }

通过实现接口获得的线程

/**
 * 使用Runable接口实现线程
 */
public class MyThread2 implements Runnable{//runnable中只有一个run方法

    @Override
  //都要对run方法进行重写
public void run() {
     //进行循环打印
for(int i = 1; i <= 10; i++){ System.out.println("线程B:"+i); } } }

测试类

public class RunThead {

    /**
     * main方法的执行就会启动一条主线程
     * 该主线程通常也将其称为守护线程或幽灵线程
     * @param args
     */
    public static void main(String[] args) {
        System.out.println("程序开始运行");
        //实例化继承了Thead线程
        MyThread1 th1 = new MyThread1("线程A");
        //开启线程,不能直接访问run方法,不然就不是开启一个线程
        th1.start();
        try {
            //将线程加入线程队列,使线程阻塞
            th1.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
     //若在外部打印状态和是否存活,状态则不一定,因为主线程和其余线程是同时进行的,不一定哪个线程先结束
     //但是加了th1.join()方法后线程阻塞了以后,则会先将线程走完,再进行主线程后面的代码,则会看到结束后的状态和不存活
System.out.println(
"main中的线程状态:"+th1.getState()); System.out.println("main中的线程是否存活:"+th1.isAlive()); //线程如果处于结束状态,无法再次启动,如果需要在启动,则需要重新创建
     
th1 = null;//赋值为null意思是这个线程结束以后要弃用了 th1 = new MyThread1("");//重新创建启用 th1.start(); //实例化实现了Runnable接口的实例 MyThread2 runnable = new MyThread2();
     //如果实现接口后直接调用,则只能调用run方法,不能算一个线程
     //th2.run(); //可以将Runnable实例封装至线程中,才是线程 Thread th2 = new Thread(runnable); th2.start();
     //由主线程进行运行 System.out.println("程序运行结束"); } }

 

 例子:时间窗体实现长时间的走动

/**
 * 通过窗体实现时间的走动
 */
public class TimeFrame extends JFrame {
//都写成属性,等到用的时候再new出来
//标签,用于呈现文字 private JLabel lbl; //开始按钮 private JButton btnStart; //停止按钮 private JButton btnStop;
   //挂起按钮
private JButton btnSuspend;    //恢复按钮 private JButton btnResume; //时间线程 private TimeThread thead;

   //构造方法
public TimeFrame(){ //设置窗体大小和位置 this.setBounds(600, 400, 600, 300); //设置窗体的关闭策略,关闭窗体时程序同时关掉 this.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE); //设置窗体的布局 this.setLayout(null); //初始化组件 initCompoent(); } /** * 初始化组件 */ private void initCompoent(){
     //初始化标签 lbl
= new JLabel();
     //再标签中添加数据 lbl.setText(
"这是一个标签,用于呈现文本");
     //设置标签的大小和位置 lbl.setBounds(
100,100,400,25); //将标签添加至窗体 this.add(lbl);
     //初始化按钮 btnStart
= new JButton("start");
     //设置按钮的大小和位置 btnStart.setBounds(
100, 150, 100, 25);
     //将按钮添加至窗体
this.add(btnStart); //绑定按钮的监听器 btnStart.addActionListener(new ButtonStartListener());

     //相同的操作设置按钮 btnStop
= new JButton("stop"); btnStop.setBounds(200, 150, 120, 25); this.add(btnStop); //绑定按钮的监听器 btnStop.addActionListener(new ButtonStopListener());

     //相同的操作设置按钮 btnSuspend
= new JButton("suspend"); btnSuspend.setBounds(300, 150, 120, 25); this.add(btnSuspend); //绑定按钮的监听器 btnSuspend.addActionListener(new ButtonSuspendListener());

     //相同的方法设置按钮 btnResume
= new JButton("resume"); btnResume.setBounds(400, 150, 120, 25); this.add(btnResume);
     //绑定按钮的监听器 btnResume.addActionListener(
new ButtonResumeListener()); } /** * start按钮监听器 */ public class ButtonStartListener implements ActionListener{ @Override public void actionPerformed(ActionEvent e) { //判断条件是为了按钮只能操作一次,多次重复点击是无用的
       //线程已经开始且线程不存活了,则可以新建一个线程
//if(thead != null && !thead.isAlive()){
       // if(thead != null && thead.getState() == Thread.State.TERMINATED){ System.out.println("前一条线程已经结束,创建了新的线程"); //创建一条新的线程 thead = new TimeThread(); //启动线程 thead.start(); } //第一次运行线程,也可以新建一个线程 else if(thead == null){ System.out.println("第一次创建新的线程"); //创建一条新的线程 thead = new TimeThread(); //启动线程 thead.start(); } } } /** * Stop按钮监听器 */ public class ButtonStopListener implements ActionListener{ @Override public void actionPerformed(ActionEvent e) { //如果线程已被创建并且处于运行时状态 if(thead != null && thead.isAlive()){ //使线程停止,提前进入销毁状态 thead.stop(); } } } /** * Suspend按钮监听器 */ public class ButtonSuspendListener implements ActionListener{ @Override public void actionPerformed(ActionEvent e) { System.out.println(thead.getState()); //如果线程处于运行时状态(不能用isAlive判断,因为阻塞的状态下也是alive) if(thead != null && (thead.getState() == Thread.State.RUNNABLE || thead.getState() == Thread.State.TIMED_WAITING)){ //将线程挂起,线程进入阻塞状态;处于suspend阻塞下的线程只能通过resume方法恢复 System.out.println("线程挂起"); thead.suspend(); } } } /** * Resume按钮监听器 */ public class ButtonResumeListener implements ActionListener{ @Override public void actionPerformed(ActionEvent e) { //对suspend线程进行恢复 if(thead != null){ thead.resume(); } } } /** * 用于刷新时间的线程 */ public class TimeThread extends Thread{ private SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); @Override public void run() { while(true){ //获取系统时间 Date date = new Date(); //将日期格式化并写入标签 lbl.setText(sdf.format(date)); try { //使线程休眠,进入到阻塞的状态,当到达指定时间后,线程将自动恢复至运行时状态
            //1000毫秒是1s Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } } } public static void main(String[] args) { //实例化窗体 TimeFrame frame = new TimeFrame(); //显示窗体 frame.setVisible(true); } }

 

stop方法需要慎用,可能会引发多线程的数据安全问题,多线程使用过程中如果产生了并发访问(多个线程对同一个对象进行了访问:比如A线程往C集合中添加数据,同时B线程也要往C集合中添加数据),需要用到线程锁(对象锁)

比如:A线程要访问C对象进行数据处理并将该C对象进行了锁定,另一个线程B也要访问C对象,但是需要等待A线程完成计算后,根据计算的结果再接着处理。此时如果A线程执行了stop方法,该方法将会释放对象锁,B线程此时会提前访问到C对象,B线程接下来的数据处理可能会出现问题

stop方法再多线程开发过程中,如果没有涉及到并发处理的情形,是没有隐患问题的

 

suspend将线程挂起,线程会进去阻塞状态,被挂起的线程只能同构resume进行恢复,两者必须一起进行使用
suspend方法可能会引起死锁,使用suspend方法调用的线程必须要通过resume方法才能恢复(图形的suspend可以通过异步调用resume,但是如果不是图形状态,再本线程中suspend后无法对自身调用resume方法,就会无限阻塞引起死锁。除非用main方法主线程进行恢复,主线程中通过调用resume)

 

以上是关于线程的主要内容,如果未能解决你的问题,请参考以下文章

活动到片段方法调用带有进度条的线程

多个用户访问同一段代码

线程学习知识点总结

JUC并发编程 共享模式之工具 JUC CountdownLatch(倒计时锁) -- CountdownLatch应用(等待多个线程准备完毕( 可以覆盖上次的打印内)等待多个远程调用结束)(代码片段

线程上的Android片段替换(...)

多个请求是多线程吗