java之线程入门到精通(一)

最新推荐文章于 2024-07-10 21:37:49 发布

842815833

最新推荐文章于 2024-07-10 21:37:49 发布

阅读量144

点赞数

分类专栏： Java线程入门到精通系列文章标签： java 多线程 thread 并发编程

本文链接：https://blog.csdn.net/u011483122/article/details/106922859

版权

Java线程入门到精通系列专栏收录该内容

1 篇文章 0 订阅

订阅专栏

一、线程和进程的概念

进程

进程是资源（CPU、内存等）分配的基本单位，它是程序执行时的一个实例。
程序运行时系统就会创建一个进程，并为它分配资源，然后把该进程放入进程就绪队列，进程调度器选中它的时候就会为它分配CPU时间，程序开始真正运行。
进程是指一个内存中运行的应用程序，比如手机里面启动的一个APP就是一个进程。

线程

线程是程序执行时的最小单位，它是进程的一个执行流，是CPU调度和分派的基本单位。
一个进程可以由很多个线程组成，线程间共享进程的所有资源，每个线程有自己的堆栈和局部变量。
线程由CPU独立调度执行，在多CPU环境下就允许多个线程同时运行。同样多线程也可以实现并发操作，每个请求分配一个线程来处理。

对比

进程是资源分配的最小单位，线程是程序执行的最小单位。
进程有自己的独立地址空间，每启动一个进程，系统就会为它分配地址空间，建立数据表来维护代码段、堆栈段和数据段，这种操作非常昂贵。
线程是共享进程中的数据的，使用相同的地址空间，CPU切换一个线程的花费远比进程要小很多，同时创建一个线程的开销也比进程要小很多。
线程之间的通信更方便，同一进程下的线程共享全局变量、静态变量等数据。
进程之间的通信需要以通信的方式（IPC)进行。不过如何处理好同步与互斥是编写多线程程序的难点。
多进程程序更健壮，多线程程序只要有一个线程死掉，整个进程也死掉了，而一个进程死掉并不会对另外一个进程造成影响，因为进程有自己独立的地址空间。

二、线程的状态之新建

新建----->就绪----->运行------>阻塞------->结束

新建线程的4种方式

1、继承Thread类创建线程

定义Thread类的子类，并重写该类的run方法，run方法的方法体就代表了线程要完成的任务。把run()方法称为执行体。
创建Thread子类的实例，即创建了线程对象
调用线程对象的start()方法来启动该线程。

import androidx.annotation.NonNull;

public class KmThread extends Thread {
    public KmThread(@NonNull String name) {
        super(name);
        System.out.println(name+"创建");
    }

    @Override
    public void run() {
        super.run();
        for(int i=0;i<10;i++){
            System.out.println(getName()+"正在执行..."+i);
        }
        System.out.println(getName()+"结束");
    }
    public static void main(String[] args) {
        KmThread mKmThread=new KmThread("继承Thread的线程");
        mKmThread.start();
    }
}

继承Thread的线程创建
继承Thread的线程正在执行...0
继承Thread的线程正在执行...1
继承Thread的线程正在执行...2
继承Thread的线程正在执行...3
继承Thread的线程正在执行...4
继承Thread的线程正在执行...5
继承Thread的线程正在执行...6
继承Thread的线程正在执行...7
继承Thread的线程正在执行...8
继承Thread的线程正在执行...9
继承Thread的线程结束

Thread的10种构造方法

public Thread() {
    init(null, null, "Thread-" +nextThreadNum(),0);
}
public Thread(Runnable target) {
    init(null, target, "Thread-" + nextThreadNum(), 0);
}
Thread(Runnable target, AccessControlContext acc) {
    init(null, target, "Thread-" + nextThreadNum(), 0, acc);
}
public Thread(ThreadGroup group, Runnable target) {
    init(group, target, "Thread-" + nextThreadNum(), 0);
}
public Thread(String name) {
    init(null, null, name, 0);
}
 public Thread(ThreadGroup group, String name) {
    init(group, null, name, 0);
}
Thread(ThreadGroup group, String name, int priority, boolean daemon) {
    this.group = group;
    this.group.addUnstarted();
    if (name == null) {
        name = "Thread-" + nextThreadNum();
    }
    this.name = name;
    this.priority = priority;
    this.daemon = daemon;
    init2(currentThread());
    tid = nextThreadID();
}
public Thread(Runnable target, String name) {
    init(null, target, name, 0);
}
public Thread(ThreadGroup group, Runnable target, String name) {
    init(group, target, name, 0);
}
public Thread(ThreadGroup group, Runnable target, String name,long stackSize) {
    init(group, target, name, stackSize);
}
/**
  * Initializes a Thread with the current AccessControlContext.
  * @see #init(ThreadGroup,Runnable,String,long,AccessControlContext)
  */
private void init(ThreadGroup g, Runnable target, String name,long stackSize) {
    init(g, target, name, stackSize, null);
}

   /**
     * Initializes a Thread.
     *
     * @param g the Thread group
     * @param target the object whose run() method gets called
     * @param name the name of the new Thread
     * @param stackSize the desired stack size for the new thread, or zero to indicate that this parameter is to be ignored.
     * @param acc the AccessControlContext to inherit, or AccessController.getContext() if null
     */
     private void init(ThreadGroup g, Runnable target, String name,long stackSize,AccessControlContext acc) {
        if (name == null) {
            throw new NullPointerException("name cannot be null");
        }
        this.name = name;
        Thread parent = currentThread();
        //这里原本有SecurityManager这个，在Android上线程里面是被移除了的，可以去看Java原版代码
        if (g == null) {
            g = parent.getThreadGroup();
        }
        g.addUnstarted();
        this.group = g;
        this.daemon = parent.isDaemon();
        this.priority = parent.getPriority();
        this.target = target;
        init2(parent);
        this.stackSize = stackSize;
        tid = nextThreadID();
    }

后面的两个init方法都是前面10种方法最后调用进行初始化的，其中最后那个init都是最终调的方法。

特别注意的是thread也是实现了Runnable的
public class Thread implements Runnable {

2、实现Runnable接口创建线程

定义runnable接口的实现类，并重写接口的run()方法，该run()方法的方法体是线程的线程执行体。
创建Runnable实现类的实例，并将其做为Thread的target来创建Thread对象，Thread对象才是真正的线程对象
最后调用线程对象的start()方法来启动该线程。

public class KmRunnable implements Runnable {
    @Override
    public void run() {
        for(int i=0;i<10;i++){
            System.out.println(Thread.currentThread().getName()+"正在执行..."+i);
        }
        System.out.println(Thread.currentThread().getName()+"结束");
    }
    public static void main(String[] args) {
        Thread mThread=new Thread(new KmRunnable(),"实现Runnable的线程");
        mThread.start();
    }
}

实现Runnable的线程正在执行...0
实现Runnable的线程正在执行...1
实现Runnable的线程正在执行...2
实现Runnable的线程正在执行...3
实现Runnable的线程正在执行...4
实现Runnable的线程正在执行...5
实现Runnable的线程正在执行...6
实现Runnable的线程正在执行...7
实现Runnable的线程正在执行...8
实现Runnable的线程正在执行...9
实现Runnable的线程结束

通过上述例子可以看出runnable最后也是放在thread里面去执行的。

3、使用Callable和Future创建线程

创建Callable接口的实现类，实现call()方法，call()方法作为线程执行体，并且有返回值。
创建Callable实现类的实例，使用FutureTask类来包装Callable对象，FutureTask对象封装了该Callable对象的call()方法的返回值。
使用FutureTask对象作为Thread对象的target创建并启动新线程
最后调用线程对象的start()方法来启动该线程。

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

public class KmCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        for(int i=0;i<10;i++){
            System.out.println(Thread.currentThread().getName()+"正在执行..."+i);
        }
        System.out.println(Thread.currentThread().getName()+"结束");
        return "KmCallable";
    }
    public static void main(String[] args) {
        KmCallable mKmCallable=new KmCallable();
        FutureTask mFutureTask=new FutureTask(mKmCallable);
        Thread mThread=new Thread(mFutureTask,"使用Callable和Future的线程");
        mThread.start();
        try {
            System.out.println("拿到返回值"+ mFutureTask.get().toString());
        } catch (ExecutionException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("----啦啦啦-----");

    }
}

使用Callable和Future的线程正在执行...0
使用Callable和Future的线程正在执行...1
使用Callable和Future的线程正在执行...2
使用Callable和Future的线程正在执行...3
使用Callable和Future的线程正在执行...4
使用Callable和Future的线程正在执行...5
使用Callable和Future的线程正在执行...6
使用Callable和Future的线程正在执行...7
使用Callable和Future的线程正在执行...8
使用Callable和Future的线程正在执行...9
使用Callable和Future的线程结束
拿到返回值KmCallable
----啦啦啦-----

//FutureTask实现RunnableFuture
public class FutureTask<V> implements RunnableFuture<V> {
}
//RunnableFuture实现Runnable
public interface RunnableFuture<V> extends Runnable, Future<V> {
}

4、使用线程池创建线程

通过Executor的工具类创建一个ExecutorService线程池
通过线程池类的submit方法去执行由实现Runnable接口创建的线程
调用线程池中的shutdown()方法关闭线程池

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class KmExecutors {
    public static void main(String[] args) {
        ExecutorService mExecutorService= Executors.newSingleThreadExecutor();
        mExecutorService.submit(new Runnable() {
            @Override
            public void run() {
                for(int i=0;i<10;i++){
                    System.out.println(Thread.currentThread().getName()+"正在执行..."+i);
                }
                System.out.println(Thread.currentThread().getName()+"结束");
            }
        });
        mExecutorService.shutdown();
    }
}

pool-1-thread-1正在执行...0
pool-1-thread-1正在执行...1
pool-1-thread-1正在执行...2
pool-1-thread-1正在执行...3
pool-1-thread-1正在执行...4
pool-1-thread-1正在执行...5
pool-1-thread-1正在执行...6
pool-1-thread-1正在执行...7
pool-1-thread-1正在执行...8
pool-1-thread-1正在执行...9
pool-1-thread-1结束

三、四种创建线程的方式对比

采用实现Runnable、Callable接口的方式创建线程时，还可以继承其他类，而直接继承Thread这种方式不行，因为Java是单继承机制。
采用实现Runnable、Callable接口的方式创建，编程稍微复杂，如果要访问当前线程，则必须使用Thread.currentThread()方法。
继承Thread类的方式创建线程时，编写简单，如果需要访问当前线程，则无需使用Thread.currentThread()方法，直接使用this即可获得当前线程。
以接口的方式创建，更适合多个相同的程序代码的线程去共享同一个资源
以接口的方式创建，实现代码和线程的独立
线程池只能放实现Runnable、Callable接口的线程，不能直接放继承Thread类的线程
采用实现Runnable、Callable接口的方式，都需要实现接口，都可以用于多线程编程，都需要调用thread.start()方法来启动线程
采用实现Runnable、Callable接口的方式，不同点在于实现Callable接口的可以返回值并且可以抛出异常，而实现Runnable接口不能有返回值，不能抛出异常。而且实现Callable接口线程，可以通过Future.cancle()这个方法取消，而Runnable不能。

以上为线程创建的四种方式，留下来的思考问题，之后需要去搞清楚的。比如说线程的底层实现原理，为啥执行run方法之后就是在子线程中执行了？

线程的创建

842815833

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java之线程入门到精通(一)

一、线程和进程的概念进程进程是资源（CPU、内存等）分配的基本单位，它是程序执行时的一个实例。程序运行时系统就会创建一个进程，并为它分配资源，然后把该进程放入进程就绪队列，进程调度器选中它的时候就会为它分配CPU时间，程序开始真正运行。进程是指一个内存中运行的应用程序，比如手机里面启动的一个APP就是一个进程。线程线程是程序执行时的最小单位，它是进程的一个执行流，是CPU调度和分派的基本单位。一个进程可以由很多个线程组成，线程间共享进程的所有资源，每个线程有自己的堆栈和局部变量。线程由
复制链接

扫一扫