Java多线程(1)

 
 

1、并行和并发

 
并发：指多个线程操作同一个资源，不是同时执行，需要交替执行，单核CPU，因为CPU执行每一个时间片很短，速度太快，看起来是同时执行（张三、李四厨师，使用同一口锅炒菜，交替执行）

并行：多核CPU，每个线程来使用一个单独的CPU的资源来运行（张三、李四厨师，一人一口锅，一起炒菜）

 

并发编程：指允许多个任务在一个时间段内重复的执行的设计结构

• 高并发：设计的程序，能够执行海量的任务同时执行
• QPS：每秒能够响应的请求数
• 吞吐量：
• 平均响应时间：
• 并发的用户数：
   
   

2、线程和进程

 
      进程就是计算机正在进行的一个独立的应用程序，进程是一个动态的概念，必须是进行状态，如果一个应用程序没有启动，那就不是一个进程线程就是组成进程的基本单位，可以完成特定的功能，一个进程是有多个线程组成
 

线程和进程的区别

 
1、内存空间
进程是有独立的内存空间，每个进程之间是相互独立的，互不干扰
线程有共享的内存空间
2、安全性
进程间是相互独立的，一个线程的奔溃不会影响到其他的进程，进程是安全的
线程存在内存的共享，一个线程的崩溃可能会影响到其他的线程的执行，线程的安全性不如进程
关系：进程是相互独立，一个进程下可以有一个或者多个线程
Java里很少使用进程概念，但是Java是可以使用进程：

Runtime runtime = Runtime.getRuntime();
//ls是Linux系统中的命令，通过Java代码调用：Java创建一个进程来执行指定的命令
Process process = runtime.exec("ls");

 
 

3、线程的创建

• 继承Thread类
• 实现Runable接口
• 实现Callable接口
   
   

实现Runable接口方式

 
Runable的接口定义如下：

在JDK的java.lang包路径下存在Runable的接口，该接口中存在抽象的run方法，实现Runable接口是要实现run方法

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

 
自定义一个实现Runable接口的Class类

/**
 * 线程的创建通过实现Runable的接口
 */
public class ImplRunable23 implements Runnable{
    @Override
    public void run() {
        //Thread.currentThread().getName()  打印当前线程的名字
        System.out.println(Thread.currentThread().getName()+"《》实现Runable接口");
    }
}

 
使用自定义类来创建多线程

 ImplRunable23 runable23 = new ImplRunable23();
        //创建线程实例
        Thread thread = new Thread(runable23);
        //start()方法启动子线程
        thread.start();
        System.out.println(Thread.currentThread().getName()+"《》主线程main");

 
 
 
 

实现Runable的创建线程步骤
1、自定义实现一个Runable接口的实现类，并实现run方法
2、实例化自定义的Runable实现类
3、创建Thread类实例，将实例化的Runable实例作为参数传递
4、启动子线程，调用Thread实例的start方法
 
 
Runable是任务体，Thread类是线程对象，线程是用来执行任务的

 
 
线程的创建也可以通过匿名内部类的方式实现，可以归结为实现Runable接口的方法
 

Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("子线程");
            }
        });
        thread1.start();

 

 

继承Thread类创建多线程

 
Thread类的定义：

• public class Thread implements Runnable

Thread类是Runable接口的实现类，实现了run方法
 

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

 
通过分析Thread类中的run方法，target是一个Runable类型的参数，通过Thread类的构造函数进行参数赋值
通过继承Thread类时，重写run方法
 

/**
 * 通过继承Thread类创建多线程
 */
public class DIYThread23 extends Thread {

    //重写run方法
    @Override
    public void run() {
        //子线程的业务都在run方法中
        System.out.println(Thread.currentThread().getName()+">>通过继承Thread类创建多线程");
    }
}

 
使用自定义Thread类来启动子线程
 

/**
         * 通过继承Thread类创建多线程
         */
        DIYThread23 thread1 = new DIYThread23();
        thread1.start();
        System.out.println(Thread.currentThread().getName()+">>主线程main");

 
实现Runable接口和Thread类的区别？

1、使用继承Thread类(单继承)是不能继承其他类，而Runable方式可以
2、继承Thread类是无法实现资源共享，而实现Runable接口可以实现资源共享
3、实现Runable接口代码更健壮，任务和线程是解耦合的，代码更加清晰，代码和数据是相互独立的
 
 

实现Callable接口

 
Callable接口声明如下：
 

public interface Callable<V> {
    V call() throws Exception;
}

 
Callable接口在java.util.concurrent包路径下，该接口提供了call方法，具体返回值，通过泛型来定义，该接口是可以抛出异常

 
 
该接口的实现类是无法直接使用的，需要接口FutureTask类
FutureTask类的定义如下：
 

public class FutureTask<V> implements RunnableFuture<V>

//RunnableFuture接口的声明
public interface RunnableFuture<V> extends Runnable, Future<V> {
    void run();
}

 
FutureTask类是继承Runable接口，即FutureTask是Runable接口的实现类，而FutureTask类提供了构造函数FutureTask(Callable callable) ，可以接口Callable类型的任务

可以通过FutureTask类将Callable类型的任务转化为Runable类型的任务
 
 
callable接口的实现类：
 

/**
 * 通过Callable接口来实现多线程
 */
public class ImplCallable23 implements Callable<String> {
    @Override
    public String call() throws Exception {
        System.out.println(Thread.currentThread().getName()+":>>通过Callable接口来实现多线程");
        return "Java23";
    }
}

 
使用自定义callable类来启动子线程
 

 /**
         * 通过实现Callable接口方式创建多线程
         */
        //Callable类型的实例=>任务体
        ImplCallable23 callable23 = new ImplCallable23();

        //需要一个将Callable类型转化为Callable类型的类？？？
        FutureTask <String> futureTask = new FutureTask <>(callable23);

        //Thread类的任务体只能接口Runable类型的任务体？
        Thread thread = new Thread(futureTask);
        thread.start();
        System.out.println(Thread.currentThread().getName()+":>>main函数");

 

实现Callable接口的创建多线程的步骤：
1、自定义实现Callable接口的实现类，并实现call方法
2、创建自定义类的实例
3、创建一个FutureTask实例，将自定义实例作为参数传入
4、创建Thread类的实例，将FutureTask的实例作为参数传入
5、启动子线程，代用Thead实例的start方法

 

Callable和Runable接口区别？
1、Callable类型的任务有返回值，而Runable类型的任务不能有返回值
2、Callable规定的方法是call(),而Runable规定的方法是run()方法
3、call()可以抛出异常，run()方法是不能排除异常的
4、Callable任务可以拿到一个Future对象，Future表示异步计算的结果，他提供了可以检查子线程是否执行完成的方法，可以获取到子线程执行的结果。通过Future对象可以了解和控制子线程的执行

 

4、线程的状态及状态转化

 

线程状态

 
Java中线程的状态由6种，Thread类中的内部类State来体现
 

public enum State {
    NEW,
    RUNNABLE,
    BLOCKED,
    WAITING,
    TIMED_WAITING,
    TERMINATED;
    
        /**
         * Thread state for a thread which has not yet started.
         */
        NEW,

        /**
         * Thread state for a runnable thread.  A thread in the runnable
         * state is executing in the Java virtual machine but it may
         * be waiting for other resources from the operating system
         * such as processor.
         */
        RUNNABLE,

        /**
         * Thread state for a thread blocked waiting for a monitor lock.
         * A thread in the blocked state is waiting for a monitor lock
         * to enter a synchronized block/method or
         * reenter a synchronized block/method after calling
         * {@link Object#wait() Object.wait}.
         */
        BLOCKED,

        /**
         * Thread state for a waiting thread.
         * A thread is in the waiting state due to calling one of the
         * following methods:
         * <ul>
         *   <li>{@link Object#wait() Object.wait} with no timeout</li>
         *   <li>{@link #join() Thread.join} with no timeout</li>
         *   <li>{@link LockSupport#park() LockSupport.park}</li>
         * </ul>
         *
         * <p>A thread in the waiting state is waiting for another thread to
         * perform a particular action.
         *
         * For example, a thread that has called <tt>Object.wait()</tt>
         * on an object is waiting for another thread to call
         * <tt>Object.notify()</tt> or <tt>Object.notifyAll()</tt> on
         * that object. A thread that has called <tt>Thread.join()</tt>
         * is waiting for a specified thread to terminate.
         */
        WAITING,

        /**
         * Thread state for a waiting thread with a specified waiting time.
         * A thread is in the timed waiting state due to calling one of
         * the following methods with a specified positive waiting time:
         * <ul>
         *   <li>{@link #sleep Thread.sleep}</li>
         *   <li>{@link Object#wait(long) Object.wait} with timeout</li>
         *   <li>{@link #join(long) Thread.join} with timeout</li>
         *   <li>{@link LockSupport#parkNanos LockSupport.parkNanos}</li>
         *   <li>{@link LockSupport#parkUntil LockSupport.parkUntil}</li>
         * </ul>
         */
        TIMED_WAITING,

        /**
         * Thread state for a terminated thread.
         * The thread has completed execution.
         */
        TERMINATED;
    }

 

New：新建状态

用new创建的线程处于新建状态，此时他和其他的Java对象一样，仅仅在堆中分配了内存
在这种状态下，使用getState()可以来获取线程状态为State.new状态

在Java中Runable状态表示正在占用CPU资源或者是等待CPU资源
在操作系统中将Java的Runable状态分为两个状态Runable状态和Running状态

Runable：就绪状态

当线程对象被创建之后，调用了start方法，线程就处于了就绪状态，处于就绪状态的线程（其他的条件都满足，可以等待CPU调度），可带获取CPU的使用权

Running：运行状态

处于运行状态的线程也就是获取到CPU的使用权，执行线程代码，只能是就绪状态的线程进入到运行状态

Blocked：阻塞状态

阻塞状态是指线程因为某些原因放弃CPU使用权（缺少资源：IO、锁），暂停运行，当前线程就处于阻塞状态

Waiting：等待状态

当前状态的线程，因为线程对象调用了wait()方法，JVM就会将线程方法到等待池中

Timed_Waiting:超时等待

sleep(long time),join(long time)会是线程处于睡眠状态

Terminated:终止状态

当线程执行到run()方法结尾处，就进入到终止状态，该状态表示线程的生命周期的结束

 
 

线程状态的转化

 

一个线程的生命周期中必不可少的状态：New、Runable、Running和Terminated四个状态，也是一个线程的生命中期中必要的状态
线程在需要响应资源时，进入到阻塞状态，阻塞状态包括Waiting、Timed_Waiting和Blocked状态

侧重点：线程状态转化方向、触发的条件
 
 
 
 
 

Java的内存模型，站在内存模型上理解堆和方法区时线程共享区域，虚拟机栈和本地方法栈、程序技术器是线程私有的
处于New状态的线程仅仅在堆空间分配了内存，运行中的线程会有虚拟机栈存在

 

 

 

 

 

 

 

 

 
参考文献：https://www.yuque.com/docs/share/11d308f6-7bec-45dc-9564-677b23387e69?#