Java中的多线程的创建方式

首先理清几个基本概念：

　　程序：为完成特定任务，用某种语言编写的一组指令的集合。即一段静态的代码（还没运行起来）

　　进程：是程序的一次执行过程，也就是说程序运行起来了，加载到了内存中，并占用了cpu的资源。这是一个动态的过程：有自身的产生、存在和消亡的过程，这也是进程的生命周期。

　　线程：进程可进一步细化为线程，是一个程序内部的执行路径。

　　若一个进程同一时间并行执行多个线程，那么这个进程就是支持多线程的。

　　线程是cpu调度和执行的单位，每个线程拥有独立的运行栈和程序计数器（pc），线程切换的开销小。

　　多线程：是指程序当中包含多个执行单元，即在一个程序中可以同时运行多个不同的线程来执行不同的任务，也就是说允许单个线程创建多个并行执行的线程来完成各自的任务。

　　Java线程的分类：用户线程和守护线程

　　java的gc（）垃圾回收线程就是一个守护线程

　　守护线程是用来服务用户线程的，通过start（）方法前调用thread.serDaemon(True)可以把一个用户线程变成守护线程

　　并行和并发：

　　　　并行：多个cpu同时执行多个任务

　　　　并发：一个cpu同时执行多个任务

　　多线程的优点

　　　　提高应用程序的相应。

　　　　提高计算机cpu的利用率

　　　　改成程序结构。将复杂的进程分成多个线程，独立运行。

线程的创建与启动

　　多线程实现的原理

　　　　java的jvm允许程序运行多个线程，多线程可以通过Java中的java.lang.Thread类来体现

　　Thread类的特性

　　　　每个线程都是通过每个特定的Thread对象的run()方法来完成操作，经常把run()方法的主体称为线程体

　　　　通过Thread方法的start()方法来启动这个线程，而非调用run（）

　　多线程的创建，方式一：继承于Thread类

　　　　1.创建一个继承于Thread类的子类

　　　　2.重写Thread类的run（）方法

　　　　3.创建Thread类的子类的对象（）

　　　　4.通过此对象调用start（）来启动一个线程

　代码实现：多线程执行同一段代码

package com.Thread.demo1;

public class demo1 extends Thread{
    @Override
    public void run(){
        for(int i = 0;i<100;i++){
            if(i % 2 == 0){
                System.out.println(Thread.currentThread().getName() + ":\t" + i);
            }
        }
    }
    public static void main(String[] args){
        demo1 test1 = new demo1();
        test1.start();
        demo1 test2 = new demo1();
        test2.start();

        new demo1().start();
        System.out.println("主线程");
    }
}

　　多线程运行多代码:

　　currentThread()可以获取当前线程的引用，一般都是在没有线程对象又需要获得线程信息时通过　　　　       Thread.currentThread()获取当前代码段所在线程的引用。

public class demo2 {
    public static void main(String[] args){
        new Threadtest1().start();
        new Threadtest2().start();
    }
}
class Threadtest1 extends Thread{
    @Override
    public void run(){
        for(int i = 0;i<100;i++){
            if(i%2==0){
                System.out.println(Thread.currentThread() + ":\t" + i);
            }
        }
    }
}
class Threadtest2 extends Thread{
    @Override
    public void run(){
        for(int i = 0;i<100;i++){
            if(i % 2 !=0){
                System.out.println(Thread.currentThread() + ":\t" + i);
            }
        }
    }
}

运行结果：

　　多线程的创建方式二：实现runnable接口

　　　　1.创建一个实现runnable接口的类

　　　　2.实现类去实现runnable接口中的抽象方法：run（）

　　　　3.创建实现类的对象

　　　　4.将此对象作为参数传到Thread类的构造器中，创建Thread类的对象

　　　　5.通过Thread类的对象调用start（）方法

public class demo3 {
    public static void main(String[] args){
        RunnableTest runnableTest = new RunnableTest();
        Thread t1 = new Thread(runnableTest);
        t1.start();
        Thread t2 = new Thread(runnableTest);
        t2.start();
    }
}
class RunnableTest implements Runnable{
    @Override
    public void run(){
        for(int i = 0;i < 100;i++){
            if(i % 2 == 0){
                System.out.println(Thread.currentThread().getName() + " " + Thread.currentThread().getId() + ":\t" + i);
            }
        }
    }
}

比较创建线程的两种方式

　　Java中只允许单进程，以children类来说，这个类如果存在父类（Person）的话，就不可以继承Thread类了，但是一个类可以实现多个接口，因此实现的方式没有类的单继承性的限制，用实现runnable接口的方式创建此类线程将更加实用！

　　实现runnable接口的方式天然具有共享数据的特性（不用static）

• 因为继承Thread的实现方式，需要创建多个子类的对象来进行多线程，如果子类中有变量A，而不使用static约束变量的话，每个子类的对象都会有自己独立的变量A，只有static约束A后，子类的对象才共享变量A。而实现Runnable接口的方式，只需要创建一个实现类的对象，要将这个对象传入Thread类并创建多个Thread类的对象来完成多线程，而这多个Thread类对象实际上就是调用一个实现类对象而已。实现的方式更适合来处理多个线程有共享数据的情况。

联系：Thread类中也实现了Runnable接口

相同点两种方式都需要重写run()方法，线程的执行逻辑都在run()方法中

　　多线程的创建方式，方式三：实现Callable接口

　　　　1.相比run()方法，可以有返回值

　　　　2.方法可以抛出异常

　　　　3.支持泛型的返回值

　　　　4.需要借助FutureTask类，比如获取返回结果

public class demo4 {
    public static void main(String[] args){
        NumSum numSum = new NumSum();
        FutureTask<Integer> future = new FutureTask<Integer>(numSum);
        new Thread(future).start();
        try{
            Integer sum = future.get();
            System.out.println("总和为："  + sum);

        }catch (InterruptedException e){
            e.printStackTrace();
        }catch (ExecutionException e){
            e.printStackTrace();
        }

    }
}

class NumSum implements Callable<Integer>{
    @Override
    public Integer call() throws Exception{
        int sum = 0;
        for (int i = 0;i<100;i++){
            if(i%2==0){
                sum+=i;
            }
        }
        return sum;
    }
}

Thread类中的常用方法

　　start（）启动当前线程，调用当前线程的run（）方法

　　run（）通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中

　　currentThread（）静态方法，返回当前代码执行的线程

　　getName（）获取当前线程的名字

　　serName（）设置当前线程的名字

　　yield（）释放当前cpu的执行权

　　join（）在线程a中调用线程b的join(), 此时线程a进入阻塞状态, 知道线程b完全执行完以后, 线程a才结束阻塞状态

　　stop（）已过时，当执行此方法，强制结束当前线程

　　sleep（long miltime）让线程睡眠指定的毫秒数，在指定时间内，线城市阻塞状态

　　isAlive（）判断当前线程是否存活