Java基础15

1.什么是进程？

        进程：在操作系统中运行的某个软件/某个程序
        任何软件/程序要运行都要被加载到内存中，而内存负责运行这个软件/程序所需要的那些内存空间，就被称为当前软件在内存中的一个进程。
        进程需要依赖于操作系统
        进程就是在操作系统中动态运行的静态代码。

2.什么是线程？

        线程就是在操作系统中动态运行的静态代码【进程】中的某一项具体功能的执行过程【执行轨迹/执行线索】。

3.什么是多线程？

        多线程:某一个程序在运行的时候可能会产生多个不同的执行线索【执行轨迹】，这些多个不同的执行线索【执行轨迹】共同运行的情况就是多线程。
       往往我们会感觉到这些多个不同的执行线索【执行轨迹】同时执行，实际上这时一种错觉假象，实际上当这些多个不同的执行线索【执行轨迹】在运行的时候，某一个时刻只有一个执行线索【执行轨迹】在运行，只是这多个不同的执行线索【执行轨迹】快速的切换而已。

4.为什么使用多线程？

        1.使用多线程的目的就是为了提高程序的执行效率。
        2.解决并发问题。
          并行和并发有什么区别？
          并行：多个处理器或多核处理器同时处理多个任务。
          并发：多个任务在同一个 CPU 核上，按细分的时间片轮流(交替)执行，从逻辑上来看那些任务是同时执行。

5.多线程的创建方式以及区别

        第一种，通过继承Thread类创建线程类

        Thread类java提供的创建线程的线程类
            创建步骤:
            1.创建一个类，继承Thread类
            2.重写run方法
            3.将需要由线程执行的具体动作写入run方法

            运行步骤:
           1.创建线程类的对象
           2.通过线程对象调用start方法启动线程

package com.wangxing.threadtest1;

/**通过继承Thread类创建线程
 * 1.创建一个类，继承Thread类
 * 2.重写run方法
 * 3.将需要由线程执行的具体动作写入run方法
 */
public class MyThread extends Thread{
    @Override
    public void run() {
        for(int i=1;i<=100;i++){
            System.out.println(Thread.currentThread().getName()+"--"+i);
        }
    }
}








package com.wangxing.threadtest1;

public class TestMyThread1 {
    public static void main(String[] args) {
        //1.创建线程类的对象
        MyThread  th1=new MyThread();
        th1.setName("线程1");
        MyThread  th2=new MyThread();
        th2.setName("线程2");
        //2.通过线程对象调用start方法启动线程
        th1.start();
        th2.start();
    }
}

        第二种，通过实现Runnable接口创建线程类

           Runnable接口--Thread类就实现过这个接口
          只有一个run方法。
          创建步骤:
          1.创建一个类，实现Runnable接口
          2.重写run方法
          3.将需要由线程执行的具体动作写入run方法

          运行步骤:
          1.创建目标对象
          2.通过Thread类的构造方法创建线程对象
          3.通过线程对象调用start方法启动线程

package com.wangxing.threadtest2;

/**通过实现Runnable接口创建线程
 *  Runnable接口中只有一个抽象方法就是run方法
 * 1.创建一个类，实现Runnable接口
 * 2.重写run方法
 * 3.将需要由线程执行的具体动作写入run方法
 */
public class MyThread implements Runnable{
    @Override
    public void run() {
        for(int i=1;i<=100;i++){
            System.out.println(Thread.currentThread().getName()+"--"+i);
        }
    }
}




package com.wangxing.threadtest2;
public class TestMyThread2 {
    public static void main(String[] args) {
        //1.创建目标对象[实现Runnable接口的子类对象]
        MyThread myThread=new MyThread();
        //2.通过Thread类的构造方法创建线程对象
        //public Thread(Runnable target)
        Thread  th1=new Thread(myThread);
        th1.setName("线程A");
        Thread  th2=new Thread(myThread);
        th2.setName("线程B");
        //3.通过线程对象调用start方法启动线程
        th1.start();
        th2.start();
    }
}

        第三种，通过Callable和Future接口创建线程

            java.util.concurrent.Callable接口--这个接口中只有一个方法call()
            java.util.concurrent.Future接口--有一个重要方法get()
               1. public boolean cancel(boolean mayInterruptIfRunning)
                是否取消正在执行的线程任务[false为取消任务]
                2. public boolean isCancelled()判断是否是线程任务没有运行结束之前取消线程
                3. public boolean isDone()判断线程任务是否正常执行完毕
                4. V get()得到线程任务的执行结果
          java.util.concurrent.FutureTask类--继承了Runnable接口
              1. public boolean cancel(boolean mayInterruptIfRunning)是否取消正在执行的线程任务
              2. public boolean isCancelled()判断是否是线程任务没有运行结束之前取消线程
              3. public boolean isDone()判断线程任务是否正常执行完毕
              4. V get()得到线程任务的执行结果

        创建步骤:
                1.创建一个类，实现Callable接口
                2.重写call();
                3.将需要由线程执行的具体动作写入call()方法
                注意:实现Callable接口的时候需要指定线程执行结果的返回值类型

        运行步骤:
                1.创建目标对象
                2.通过FutureTask类的构造方法public FutureTask(Callable<V> callable)封装目标对象成Runnable子类对象
                3.通过Thread类的构造方法public Thread(Runnable runnable)创建线程对象

package com.wangxing.test3;

import java.util.concurrent.Callable;

/**
 * 1.创建一个类，实现Callable接口
 * 2.重写call();
 * 3.将需要由线程执行的具体动作写入call()方法
 * @author Administrator
 *
 */
public class MyThread implements Callable<Integer>{
	@Override
	public Integer call() throws Exception {
		int i=1;
		while(i<=50){
			//得到当前线程的名称
			String name=Thread.currentThread().getName();
			System.out.println(name+"--i=="+i);	
			i++;
		}
		return i;
	}
}




package com.wangxing.test3;

import java.util.concurrent.FutureTask;

public class MyThreadMain {

	public static void main(String[] args) {
		//1.创建目标对象
		MyThread  my1=new MyThread();
		//2.通过FutureTask类的构造方法public FutureTask(Callable<V> callable)封装目标对象成Runnable子类对象
		FutureTask  futruetask1=new FutureTask(my1);
		FutureTask  futruetask2=new FutureTask(my1);
		//3.通过Thread类的构造方法public Thread(Runnable runnable)创建线程对象
		Thread  th1=new Thread(futruetask1);
		Thread  th2=new Thread(futruetask2);
		//启动线程
		th1.start();
		th2.start();
		//是否取消正在执行的线程任务
		//futruetask1.cancel(false);
		//判断是否是线程任务没有运行结束之前取消线程
		//System.out.println(futruetask1.isCancelled());
		//判断线程任务是否正常执行完毕
		//System.out.println(futruetask1.isDone());
		try{
			//得到线程运行结果
			int res=(Integer)futruetask1.get();
			System.out.println("线程1的运行结果=="+res);
			}catch(Exception e){
				e.printStackTrace();
			}
	}

}

4.多线程的创建方式的区别

        继承Thread类
            1.创建新类继承Thread类重写run方法
            2.run方法没有返回值，不能声明抛出异常
            3.创建Thread类的子类对象【线程对象】，通过子类对象调用start方法启动线程
            4.无法资源共享
            5.不考虑资源共享时

         实现Runnable接口
            1.创建新类实现Runnable接口重写run方法
            2.run方法没有返回值，不能声明抛出异常
            3.创建实现Runnable接口的子类对象【目标对象】，通过Thread的构造方法将目标对象转换成线程对象，通过线程对象调用start方法启动线程
            4.可以资源共享
            5.考虑资源共享时

         Callable和Future接口
            1.创建新类实现Callable接口重写call方法，注意Callable接口的泛型类型
            2.call方法有返回值，通过Future接口提供的get方法得到返回值,可以声明抛出异常
            3.创建实现Callable接口的子类对象【目标对象】，通过Future接口的子类FutureTask将Callable接口的子类转换成Runnable接口类型，通过Thread的构造方法将Runnable接口类型对象转换成线程对象，通过线程对象调用start方法启动线程。
            4.可以资源共享
            5.考虑资源共享时，异步编程