java中的多线程1

1什么是进程？

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

2.什么是线程？

  线程就是在操作系统中动态运行的静态代码【进程】中的某一项具体功能的执行过程【执行轨迹/执行线索】。
  例如：
         我们在window操作系统上打开“暴风影音”播放电影，此时“暴风影音”就会在window操作系统中产生一个进程；打
  开“暴风影音”播放电影的时候有画面，声音，中文字幕等等,这些画面，声音，中文字幕就是这个“暴风影音”进程中的
  多个线程。

进程	线程
依赖操作系统	依赖进程
进程与进程之间的数据交互很困难	线程与线程之间的数据交互很容易

3.什么是多线程？

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

4.为什么使用多线程？

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

同步和异步有什么区别？

    同步：当操作系统运行一个程序时，只有这个程序运行完，才能执行其他的。
    异步：操作系统中可以同时运行几个程序

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

  Java中的线程
     当一个java程序启动运行以后，至少有2个线程在运行。
      1.主线程,就是java程序的主方法执行线索
      2.垃圾回收线程。
    Java中多线程的创建方式【4种】
    1.通过继承Thread类创建线程类
      1.创建一个类，继承Thread类
      2.重写run方法
      3.将需要由线程执行的具体动作写入run方法

package com.wangxing.threaddemo1;
/**
 * 通过继承Thread类创建线程类
 *  1.创建一个类，继承Thread类
 *  2.重写run方法
 *  3.将需要由线程执行的具体写入run方法
 * @author feng
 *
 */
public class MyThread extends Thread {
	@Override
	public void run() {
		//得到当前线程的名字
		//Thread.currentThread()表示当前线程对象
		String threadname=Thread.currentThread().getName();
		for(int i=1;i<=100;i++){
			System.out.println(threadname+"i="+i);
		}
	}
}

//测试类
package com.wangxing.threaddemo1;
public class TestMain {
	public static void main(String[] args) {
		//通过继承Thread类创建线程类
		//1.创建线程对象
		MyThread mt1=new MyThread();
		MyThread mt2=new MyThread();
		//通过调用start方法启动线程运行
		mt1.start();
		mt2.start();
	}
}

   2.通过实现Runnable接口创建线程类
      1.创建一个类，实现Runnable接口
      2.重写run方法
      3.将需要由线程执行的具体动作写入run方法

package com.wangxing.threaddemo2;
/**
 * 通过实际Runnable接口创建线程类
 *  1.创建一个类，实现Runnable接口
 *  2.重写run方法
 *  3.将需要由线程执行的具体动作写入run方法
 * @author feng
 *
 */
public class DoxThread implements Runnable {
	@Override
	public void run() {
		//得到当前线程的名称
		String threadname=Thread.currentThread().getName();
		for(int i=1;i<=100;i++){
			System.out.println(threadname+"i="+i);
		}
	}
}

//测试类
package com.wangxing.threaddemo2;
public class TestMain {
	public static void main(String[] args) {
		//通过实现Runnable接口创建线程类
		//目标对象
		DoxThread dt=new DoxThread();
		//创建线程对象
		Thread th1=new Thread(dt);
		Thread th2=new Thread(dt);
		//调用start方法启动线程运行
		th1.start();
		th2.start();
		//线程的启动必要Thread或Thread的子类构成的对象，这样才可以启动线程
		//实现Runnable接口的类构件的对象是目标对象，不是线程对象。不能启动线程
		//通过线程的构造方法  Thread th=new Thread(Runnable target)
	}
}

   3.通过Callable和Future接口创建线程
      通过这两个接口创建线程，你要知道这两个接口的作用，下面我们就来了解这两个接口：
             通过实现Runnable接口创建多线程时，Thread类的作用就是把run()方法包装成线程的执行体,那么，是否可以直接把任意方
      法都包装成线程的执行体呢?
             从JAVA5开始，JAVA提供提供了Callable接口，该接口是Runnable接口的增强版，Callable接口提供了一个call()方法可以作
      为线程执行体，但call()方法比run()方法功能更强大，call()方法的功能的强大体现在：
             1.call()方法可以有返回值；
             2.call()方法可以声明抛出异常；
      从这里可以看出，完全可以提供一个Callable对象作为Thread的target，而该线程的线程执行体就是call()方法。
      问题是：Callable接口是JAVA新增的接口，而且它不是Runnable接口的子接口，所以Callable对象不能直接作为Thread的target。
                    还有一个原因就是：call()方法有返回值，call()方法不是直接调用，而是作为线程执行体被调用的，所以这里涉及获取
                    call()方法返回值的问题。
            于是，JAVA5提供了Future接口来代表Callable接口里call()方法的返回值，并为Future接口提供了一个FutureTask实现类，该
     类实现了Future接口，并实现了Runnable接口，所以FutureTask可以作为Thread类的target，同时也解决了Callable对象不能作为
     Thread类的target这一问题。
     在Future接口里定义了如下几个公共方法来控制与它关联的Callable任务：
        1.boolean   cancel(boolean mayInterruptIfRunning)：试图取消Future里关联的Callable任务；
        2.V    get()：返回Callable任务里call()方法的返回值，调用该方法将导致程序阻塞，必须等到子线程结束以后才会得到返回值；
        3.V    get(long timeout, TimeUnit unit)：返回Callable任务里call()方法的返回值。该方法让程序最多阻塞timeout和unit指定的时间，
                                                                       如果经过指定时间后，Callable任务依然没有返回值，将会抛出TimeoutException异常；
        4.boolean    isCancelled()：如果Callable任务正常完成前被取消，则返回true；
        5.boolean   isDone()：如果Callable任务已经完成， 则返回true；
      这种方式创建并启动多线程的步骤如下：
        1.创建Callable接口实现类，并实现call()方法，该方法将作为线程执行体，且该方法有返回值，再创建Callable实现类的实例；
        2.使用FutureTask类来包装Callable对象，该FutureTask对象封装了该Callable对象的call()方法的返回值；
        3.使用FutureTask对象作为Thread对象的target创建并启动新线程；
        4.调用FutureTask对象的get()方法来获得子线程执行结束后的返回值。

package com.wangxing.threaddemo3;
import java.util.concurrent.Callable;
/**
 * 通过Callable和Future接口创建线程
 *  1.新建一个java类，实现Callable接口
 *  注意：为Callable接口提供泛型类型，泛型类型就是call()的返回值类型
 *  2.重写call方法
 *  3.将需要由线程执行的动作写入call方法中注意返回值
 * @author feng
 *
 */
public class TestThread implements Callable {
	@Override
	public String call() throws Exception {
		//得到当前线程的名字
		String threadname=Thread.currentThread().getName();
		for(int i=1;i<=100;i++){
			System.out.println(threadname+"i="+i);
		}
		return threadname+"执行完毕";
	}
}

//测试类
package com.wangxing.threaddemo3;
import java.util.concurrent.FutureTask;
public class TestMain {
	public static void main(String[] args)throws Exception {
		//通过Callable和Future接口创建线程
		//创建目标对象
		TestThread tt=new TestThread();
		//将目标对象包装成Runnable接口的子类---【Future的子类】
		FutureTask ft1=new FutureTask(tt);
		FutureTask ft2=new FutureTask(tt);
		//创建线程对象
		Thread th1=new Thread(ft1);
		Thread th2=new Thread(ft2);
		th1.start();
		th2.start();
		//得到call返回值
		String returnvalue1=ft1.get();
		System.out.println("线程1的call方法返回值=="+returnvalue1);
		String returnvalue2=ft2.get();
		System.out.println("线程2的call方法返回值=="+returnvalue2);
		//Callable接口---jdk5.0后才有的---任意方法都包装成线程的执行体
		//call()---线程执行体 1.有返回值  2.可以声明抛出异常
		//Future接口---1.得到call方法返回值
		//      2.通过他的子类FutureTask将Callable接口的子类转换成线程的目标对象
		//大部分异步编程使用此方式创建线程操作
	}
}

   4.通过线程池创建多线程【使用的比较少，所以不强调】

区别

继承Thread类	实现Runnable接口	Callable和Future接口
创建新类继承Thread类重写run方法	创建新类实现Runnable接口重写run方法	创建新类实现Callable接口重写call方法，注意Callable接口的泛型类型
run方法没有返回值，不能声明抛出异常		call方法有返回值，通过Future接口提供的get方法得到返回值,可以声明抛出异常
创建Thread类的子类对象【线程对象】，通过子类对象调用start方法启动线程	创建实现实现Runnable接口的子类对象【目标对象】，通过Thread的构造方法，关联目标对象，创建线程对象【Thread类的对象】，通过线程对象调用start方法启动线程	创建实现Callable接口的子类对象【目标对象】，通过Future接口的子类FutureTask将目标对象包装成Runnable接口的子类对象，通过Thread的构造方法，关联FutureTask包装成的Runnable接口的子类对象，创建线程对象【Thread类的对象】，通过线程对象调用start方法启动线程
无法资源共享	可以资源共享	可以资源共享
不考虑资源共享时运用这种方式创建多线程	考虑资源共享时运用这种方式创建多线程	考虑资源共享时，异步编程（这种方式有返回值所以可以异步）

package com.wangxing.threaddemo4;
public class MyThread extends Thread {
	private int piao=5;
	@Override
	public void run() {
		boolean flag=true;
		while(flag){
			if(piao>0){
				piao=piao-1;
				//得到当前线程的名称
				String threadname=Thread.currentThread().getName();
				System.out.println(threadname+
					"卖出一张票，还剩"+piao);
			}else{
				flag=false;
			}
		}
	}
}

package com.wangxing.threaddemo4;
public class TestThread implements Runnable {
	private int piao=5;
	@Override
	public void run() {
		boolean flag=true;
		while(flag){
			if(piao>0){
				piao=piao-1;
				//得到当前线程的名称
				String name=Thread.currentThread().getName();
				System.out.println(name+"卖出一张票，还剩"+piao);
			}else{
				flag=false;
			}
		}
	}
}

package com.wangxing.threaddemo4;
public class TestMain {
	public static void main(String[] args) {
		/*
		 * 数据不共享
		MyThread mt1=new MyThread();
		MyThread mt2=new MyThread();
		mt1.start();
		mt2.start();
		*/
        //数据共享
		TestThread tt=new TestThread();
		Thread th1=new Thread(tt);
		Thread th2=new Thread(tt);
		th1.start();
	    th2.start();	
	}
}