实现线程操作的三种方法

1-1 进程

• 程序是静止的，运行中的程序就是进程。

• 进程的三个特征：

  • 动态性 ： 进程是运行中的程序，要动态的占用内存，CPU和网络等资源。
  • 独立性 ： 进程与进程之间是相关独立的，彼此有自己的独立内存区域。
  • 并发性 ： 假如CPU是单核，同一个时刻其实内存中只有一个进程在被执行。 CPU会分时轮询切换依次为每个进程服务，因为切换的速度非快，给我们的感觉这些进程在同时执行，这就是并发性。
  • 并行：同一个时刻同时在执行。

1-2 线程

• 线程是属于进程的。一个进程可以包含多个线程，这就是多线程。线程创建开销相对于进程来说比较小。 线程也支持并发性。
• 线程的作用: 可以提高程序的效率，可以有更多机会得到CPU。

1-3 进程和线程的总结

• 进程是运行中的程序。有动态性，独立性，并发性。一个进程可以包含多个线程，线程也支持并发。

• 多线程可以提高程序的整体效率，可以解决很多业务需求。因为多个线程是并发抢占CPU执行，所以多线程的执行会出现随机性。

2-创建线程的三种方式

方式1：定义一个线程类继承Thread类，然后重写run()方法，再创建线程对象，调用start()方法启动线程

/**
方式一的步骤：
 a.定义一个线程类继承Thread类
 b.重写Thread类的run()方法
 c.创建一个子线程对象
 d.调用线程对象的start()方法启动线程（其实最终就是执行线程对象的run()方法）

 线程的注意：
 1.启动线程不能直接调用run()方法，否则是普通对象的普通方法调用了，将失去线程特征。线程的启动必须调用start()
 2.一般是先创建子线程，再申明主线程的任务，否则主线程任务总是先执行完！

 优缺点：
   优点：编码简单。
   缺点：线程类已经继承了Thread类，不能再继承其他类，功能被削弱了。不能做线程池。无法直接返回线程执行的结果。
 */
public class ThreadDemo {
    // 自带一个线程：main方法本身就是一个线程，是最牛逼的线程！
    public static void main(String[] args) {
        //  c.创建一个子线程对象
        MyThread t = new MyThread();
        //  d.启动线程
        // 注意：启动线程不能直接调用run()方法，否则是普通对象的普通方法调用了，将失去线程特征。
        // 线程的启动必须调用start()
        t.start();

        for(int i = 0 ;  i < 10; i++){
            System.out.println("main线程执行："+i);
        }
    }
}

// 线程类不是线程对象，是用来创建线程对象的。
//  a.定义一个线程类继承Thread类
class MyThread extends Thread{
    //  b.重写Thread类的run()方法
    @Override
    public void run() {
        for(int i = 0 ;  i < 10; i++){
            System.out.println("子线程执行："+i);
        }
    }
}

方式2：定义一个线程任务类实现Runnable接口，然后重写run()方法。创建线程任务对象，把线程任务对象包装成线程对象，调用start()方法启动线程

/**
a.定义一个线程任务类实现Runnable接口。重写run()方法
b.创建一个线程任务对象
c.把线程任务对象包装成一个线程对象
	-- public Thread(Runnable target)
d.调用线程对象的start()方法启动线程。

优缺点：
	缺点：编程相对复杂，不能直接返回线程的执行结果
	优点：
		 1. 一个任务对象可以被反复包装成多个线程对象。
		 2. 可以避免java中的单继承的局限性。因为线程任务对象只是实现了接口，还可以继续继承其他类和实现其他接口。
		 3. 实现解耦操作，线程任务对象代码可以被多个线程共享，代码和线程独立。
		 4. 线程池只能放入实现Runable或Callable类线程，不能直接放入继承Thread的类。适合做线程池。
 */
public class ThreadDemo {
    public static void main(String[] args) {
        // b.创建一个线程任务对象
        Runnable target = new MyRunnable();
        // c.把线程任务对象包装成线程对象
        Thread t = new Thread(target);
        // d.调用线程对象的start()方法启动线程。
        t.start();

        Thread t1 = new Thread(target);
        t1.start();

        for(int i = 0 ;  i < 10; i++){
            System.out.println(Thread.currentThread().getName()+"=>"+i);
        }
    }

}
// 线程任务类
//   a.定义一个线程任务类实现Runnable接口。
class MyRunnable implements Runnable{
    @Override
    public void run() {
        for(int i = 0 ;  i < 10; i++){
            System.out.println(Thread.currentThread().getName()+"=>"+i);
        }
    }
}

方式三：定义一个线程任务类实现Callable接口

/**
a.定义一个线程任务类实现Callable接口。
b.重写call()方法。
c.把线程任务对象包装成一个未来任务对象。
d.把未来任务对象包装成一个线程对象。
e.调用线程对象的start()方法启动线程。
优缺点：
	缺点：编码复杂。
	优点：全是优点。
		可以继续继承其他类。
		可以做线程池。
		可以得到线程返回的结果。
		可以做资源共享操作

 */
public class ThreadDemo {
    public static void main(String[] args) {
        MyCallable call = new MyCallable();
        // c.把线程任务对象包装成一个未来任务对象。
        /**
         * 未来任务对象： FutureTask
         *  1.可以通过未来任务对象去获取线程执行的结果。
         *  2.未来任务对象其实就是一个Runnable的对象。
         */
        FutureTask<String> target = new FutureTask<>(call);
        //  d.把未来任务对象包装成一个线程对象。
        Thread t = new Thread(target);
        //  e.调用线程对象的start()方法启动线程。
        t.start();

        for(int i = 0 ;  i < 10; i++){
            System.out.println(Thread.currentThread().getName()+"=>"+i);
        }

        try {
            // 线程的执行的结果！
            String result = target.get();
            System.out.println(result);
        }  catch (Exception e) {
            e.printStackTrace();
        }
    }
}
//  a.定义一个线程任务类实现Callable接口。申明返回值类型
class MyCallable implements Callable<String>{
    //  b.重写call()方法。
    @Override
    public String call() throws Exception {
        int count = 0 ;
        for(int i = 0 ;  i < 10; i++){
            count+=(i+1) ; // 1-10的和。
            System.out.println(Thread.currentThread().getName()+"=>"+i);
        }
        return Thread.currentThread().getName()+"求和结果："+count;
    }
}