Java线程基础

最新推荐文章于 2024-04-18 01:00:00 发布

programming_dl

最新推荐文章于 2024-04-18 01:00:00 发布

阅读量602

点赞数 1

文章标签： java

本文链接：https://blog.csdn.net/weixin_40536930/article/details/82433220

版权

Java中线程的生命周期：
线程周期

Java线程中的状态
初始状态（New）
当线程对象创建后，则进入开启一个线程状态（Thread t = new MyThread();）
就绪状态（Runnable）
当调用线程对象的start()方法（t.start()），线程进入了就绪状态。处于就绪状态的线程，知识说明此线程已经做好了准备，随时等待CPU调度执行，并不是说明调用了start方法茨县丞立即就会执行。
运行状态（Running）
当CPU开始调度处于就绪状态的线程时，此时线程才得以真正执行，即进入到运行状态。就绪状态时进入运行状态的唯一入口。也就是说，线程要想进入运行状态执行，首先必须处于就绪状态中。
阻塞状态（Blocked）
处于运行状态中的线程由于某种原因，暂时放弃对CPU的使用权，停止执行，此时进入阻塞状态，知道其进入到就绪状态，才有机会再次被CPU调用以进入到运行状态。根据阻塞产生的原因不同，阻塞状态又可以分为三种：

等待阻塞：运行状态中的线程执行wait()方法，使本线程进入到等待阻塞状态
同步阻塞：线程在获取sunchronized同步锁失败（因为锁被其它线程所占用），它会进入同步阻塞状态
其他阻塞：通过调用线程sleep()或join()或发出了I/O请求时，线程会进入到阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。
死亡状态（Dead）：当线程执行完或者因异常退出run()方法，该线程结束生命周期

Java多线程的创建及启动
java中线程的创建常见由三种基本形式

继承Thread类，重写run()方法

package sun.java.thread;

public class MyThread extends Thread {
    @Override
    public void run() {
        // TODO Auto-generated method stub
        for (int i = 0; i < 50; i++) {
            //输出线程运行五十次当前线程名称
            System.out.println(Thread.currentThread().getName() + "\t" + i);
        }
    }
}

运行

package sun.java.thread;

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

        for (int i = 0; i < 30; i++) {
            //输出当前线程名称
            System.out.println(Thread.currentThread().getName()+"\t"+i);
            if(i==10){
                //使用线程Thread1
                MyThread t1 = new MyThread();
                //使用线程Thread2
                MyThread t2 = new MyThread();
                t1.start();
                t2.start();
            }
        }
    }
}

继承Thread类，通过重写run（）方法定义了一个新的线程类MyThread，其中run()方法的方法体代表了线程需要完成的任务，称之为线程执行体。当创建此线程对象时一个新的线程得以创建，并进入到线程新建状态，通过调用线程对象引用的Start()方法，使得该线程进入就绪状态，此时此线程并不一定马上得以执行，这取决于CPU的调度时机。
实现Runnable接口，并重写该接口的run()方法，该run()方法同样是线程执行体，创建Runnable实现类的实例，并以此实例作为Thread类的target来创建Thread对象，该Thrad对象才是真正的线程对象

package sun.java.thread;

public class MyRunnatble implements Runnable{

    @Override
    public void run() {
        // TODO Auto-generated method stub
        for (int i = 0; i < 20; i++) {
            System.out.println(Thread.currentThread().getName()+"\t"+i);
        }
    }

}

运行

package sun.java.thread;

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

        for (int i = 0; i < 30; i++) {
            System.out.println(Thread.currentThread().getName()+"\t"+i);
            if(i == 10){
                MyRunnatble run = new MyRunnatble();

                Thread t1 = new Thread(run);
                Thread t2 = new Thread(run);

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

查看Runnable与Thread的区别

package sun.java.thread;

public class ThreadInfo {
    public static void main(String[] args) {
        for(int i = 0; i < 50; i++ ){
            System.out.println(Thread.currentThread().getName()+"\t"+i);
            if(i == 20){
                IRunnable run = new IRunnable();
                IThread t = new IThread(run);
                t.run();
                t.start();
            }
        }
    } 
}
class IRunnable implements Runnable{

    @Override
    public void run() {
        // TODO Auto-generated method stub
        for(int i = 0; i < 10; i++ ){
            System.out.println("This is Runnable:\t"+Thread.currentThread().getName()+"\t"+i);
        }
    }
}
class IThread extends Thread{

    public IThread(Runnable runnable) {
        // TODO Auto-generated constructor stub
        super(runnable);
    }

    @Override
    public void run() {
        // TODO Auto-generated method stub
        for (int i = 0; i < 10; i++) {
            System.out.println("This is Thread:\t"+Thread.currentThread().getName()+"\t"+i);
        }
    }
}

结果如图
Runnable与Thread区别
同样的，与实现Runnable接口创建线程方式相似，不同的地方在于

IRunnable run = new IRunnable();

那么这种方式可以创建一个新的线程么?答案使肯定的。至于此时的线程执行体到底使IRunnable接口中的run()方法还是IThread中的run方法呢？通过输出我们知道线程执行体使MyThread类中的run方法。其实原因很简单，因为Thread类本省也是实现了Runnable接口，而run方法最先是在Runnable接口中定义的方法。

public interface Runnable{
    public abstract void run();
}

我们看一下Thread类中对Runnable接口中的run方法的实现：

public class Thread{
    ...

    /* What will be run. */
    private Runnable target;

    ........

    @Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }
    ...
}

也就是说，当执行Thread类中的run方法时，会首先判断target是否存在，存在则执行target中的run方法，也就是实现了Runnable接口并重写了run方法的类中的run方法。但是上述给到的例子中，由于多态的存在，根本就没有执行到Thread类中的run方法，而是直接先执行了运行时类型IThread类中的run方法。

使用Callable和Future接口创建线程。具体时创建Callable接口的实现类，并实现clall方法。并使用FutureTask类来包装Callable实现类的对象，且一次FutureTask对象作为Thread对象的target来创建线程

代码实例

package sun.java.thread;

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

public class FutureTaskDemo {
    public static void main(String[] args) {
        for (int i = 0; i < 30; i++) {
            ICallable callable = new ICallable();
            FutureTask<Integer> ft = new FutureTask<>(callable);
            System.out.println("Current Thread is run!My Thread name is :"+Thread.currentThread().getName());
            if(i == 10){
                Thread t = new Thread(ft);
                t.start();
                System.out.println("Thread is off .....");

                try {
                    int sum = ft.get();
                    System.out.println("Thread is run count :"+sum);
                } catch (Exception e) {
                    // TODO: handle exception
                    e.printStackTrace();
                }
            }
        }
    }
}
class ICallable implements Callable<Integer>{

    @Override
    public Integer call() throws Exception {
        // TODO Auto-generated method stub
        int sum = 0;
        for (int i = 0; i < 10; i++) {
            System.out.println("This is Callable call() is running !\t"+i);
            sum = i + sum;
        }
        return sum;
    }
}

在实现Callable接口中，此时不再是run方法，而是call方法，此call方法作为线程执行体，同时还具有返回值!在创建新线程时，时通过FutureTask来包装ICallable对象，同时作为了Thread对象的target

FutrueTask类的定义

FutureTask类的定义
FutureTask实现的接口
可以看出FutrueTask类实习上时同时实现了Runnable和Futrue接口，由此才是的其具有Futrue和Runnable双重特性。通过Runnable特性，可以作为Thread对象的target，而Future特性，可以获得新线程中的call方法的返回值。

执行程序，sum = 45永远是最后输出的。而”Thread is off…”则很可能是在子线程循环中间输出。由CPU的线程调度机制，我们知道”Thread is off…”的输出时机是没有任何问题的，那么为什么sum的值是最后输出？

原因在于通过ft.get()方法获取子线程call()方法的返回值时，当子线程此方法还未执行完毕，ft.get()方法会一直阻塞，知道call()方法执行完毕才能获取返回值。

代码示例总过举出三种常见的线程创建方式，对于线程的启动而言，都是调用线程对象的start()方法，需要特别注意的是：不能对统一线程对象两次调用start()方法

Java多线程就绪、运行和死亡状态

就绪状态为运行状态：当此线程得到处理器资源

运行状态为就绪状态：当此线程主动调用yieId()方法或在运行过程中失去处理资源。

运行状态转换为死亡状态：当此线程执行体完毕或发生了异常。

注意
当调用线程的yieId()方法时，线程从运行状态转换为就绪状态，但接下来CPU调度就绪状态中的那个线程具有一定的随机性，因此，可能会出现A线程调用了yieId()方法后，接下来CPU仍然调度了A线程的情况。

由于实际的业务需要，常常会遇到需要在特定时机终止某一线程的运行，使其进入死亡状态，目前最通用的做法时设置一个boolean变量，当条件满足时，使线程执行体快速执行完毕：

代码实例

package sun.java.thread;

public class ThreadDemo {
    public static void main(String[] args) {
        for (int i = 0; i < 30; i++) {
            System.out.println(Thread.currentThread().getName()+i);
            MRunnable run = new MRunnable();
            Thread t = new Thread(run);
            if(i == 20){
                t.start();
            }
            if(i == 30){
                run.stopThread();
            }
        }
    }
}
class MRunnable implements Runnable{

    //yes or no off Thread
    private boolean stop;

    @Override
    public void run() {
        // TODO Auto-generated method stub
        for (int i = 0; i < 10; i++) {
            System.out.println("Runnable is run() start!" + i);
        }
    }

    /**
     * 当调用方法，在业务中获取stop值执行判断确认关闭线程
     */
    public void stopThread() {
        this.stop = true;
    }
}

programming_dl

关注

1
点赞
踩
6

收藏

觉得还不错? 一键收藏
打赏
0
评论
Java线程基础

Java中线程的声明周期： Java线程中的状态初始状态（New）当线程对象创建后，则进入开启一个线程状态（Thread t = new MyThread();）就绪状态（Runnable）当调用线程对象的start()方法（t.start()），线程进入了就绪状态。处于就绪状态的线程，知识说明此线程已经做好了准备，随时等待CPU调度执行，并不是说明调用了start方法茨县丞...
复制链接

扫一扫