多线程学习(二)-----线程的实现（重点）

多线程

英语:multithreading,
是指从软件或者硬件上实现多个线程并发执行的技术

重点:当多个线程跑起来时,没有先后顺序.

线程实现的方式:

四种方法：

方法一：继承·Thread类，重写run方法

	不建议使用，无法避免OOP单继承局限性

方法二：实现Runable接口，实现run方法 
		
	建议使用，避免了单继承局限性，灵活方便，方便同一个对象被多个线程使用

方法三：实现Callable接口，实现call方法

方法四：线程池

方法一：继承Thread类

1. 定义MyThread类继承Thread方法

2. 重写run方法，编写线程执行体

3. 创建线程对象，调用start方法启动线程

static Thread currentThread() 返回对当前正在执行的线程对象的引用

class MyThread extends Thread{
	public void run{
		//逻辑处理
	}
}
//主函数内的启动方式:
MyThread myThread = new MyThread();
myThread.start();

实例：

//创建线程方式一：继承Thread类，重写run()方法，调用start开启线程
public class TestThread1  extends Thread{
    @Override
    public void run() {
        //run方法线程体
        for (int i = 0; i < 100; i++) {
            System.out.println("我在执行test1线程--->"+i);
        }
    }

    public static void main(String[] args) {
        //main线程

        //创建一个线程对象
        Thread threadtest1 = new TestThread1();
        //调用start（）方法开启线程
        threadtest1.start();

        for (int i = 0; i <100 ; i++) {
            System.out.println("我在执行main线程--->"+i);
        }
    }
}

方法二：实现Runable接口

1. 定义MyRunable类实现Runable接口

2. 实现run方法，编写线程执行体

3. 创建线程对象，调用start方法启动线程

class MyRunnable implements Runnable{
	public void run{
	//逻辑处理
	}
 }
 //主函数内的启动方式
 MyRunnable myRunnable = new MyRunnable();
 Thread thread = new Thread(myRunnable);
 thread.start();

实例1：

//创建线程方式二：实现Runable类，实现run()方法，调用start开启线程
public class TestThread2 implements Runnable {
    @Override
    public void run() {
        //run方法线程体
        for (int i = 0; i < 100; i++) {
            System.out.println("我在执行test2线程--->" + i);
        }
    }

    public static void main(String[] args) {

        //创建runable接口的实现类对象
        TestThread2 testThread2 = new TestThread2();
        //创建线程对象，通过线程对象开启我们的线程，代理
        Thread thread = new Thread(testThread2);
        thread.start();

        for (int i = 0; i <100 ; i++) {
            System.out.println("我在执行main线程--->"+i);
        }

    }
}

实例2:

package com.DuoXianCheng;

import com.sun.javafx.sg.prism.web.NGWebView;

/**
* currentThread()
* 返回当前线程
*线程的休眠
* 在当前的线程的执行过程中,暂停指定的毫秒数,释放CPU的时间片
*/

public class ThreadDemo1 {
   public static void main(String[] args) {
       //继承Thread类 启动方式
   MyThread myThread = new MyThread();
   myThread.start();//启动线程
       //实现Runnable接口 启动方式
   MyRunnable myRunnable=new MyRunnable();
   Thread thread =new Thread(myRunnable);
   thread.start();//启动线程
   }
}

/**
* 实现线程的第一种方式:继承Thread类
*/
class MyThread extends Thread{
   @Override
   public void run() {
       for (int i = 0; i <50 ; i++) {
           System.out.println(Thread.currentThread().getName()+"-"+i);
           //线程的休眠
           try {
               Thread.sleep(500);
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
       }
   }
}

/**
* 实现线程的第二种方式:实现Runnable接口
*/
class MyRunnable implements Runnable{
   @Override
   public void run() {
       for (int i = 0; i <50 ; i++) {
           System.out.println(Thread.currentThread().getName()+"-"+i);
           try {
               Thread.sleep(500);
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
       }
   }
}

方法三：实现Callable接口

1. 定义MyCallable类实现Callable接口,泛型为call方法的返回值

2. 实现call方法，编写线程执行体

3. 创建线程对象，调用start方法启动线程

class MyCallable implements Callable<T>{
	public T call{
		//逻辑处理
		return ; 
	}
 }
 //主函数内的启动方式
MyCallable myCallable = new MyCallable ();
FutureTask<T> future= new FutureTask<T>(myCallable) ;
//FutureTask类是Runnable接口的子类，所以可以使用Thread类的构造来接收FutureTask的实例化对象
new Thread(future).start();
System.out.println("线程的返回结果：" + future.get()) ;