多线程（1）

多线程：
进程：正在执行中的程序，其实是应用程序在内存中运行的区域。

线程：进程中的一个执行单元，负责进程中的程序的运行，一个进程中至少要有一个线程。
一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。

程序启动了多线程，有什么应用呢？
可以实现多部分程序同时执行，专业术语称之为 并发。

多线程的使用可以使用cpu的资源，如果线程过多会导致性能降低。

cpu处理程序时是通过快速切换完成的，在我们看来好像是随机一样。

什么时候使用多线程技术呢？
当多部分代码需要同时执行时，就需要使用多线程技术。

代码演示引入多线程的前后的区别

class Demo{    private String name;    Demo(String name)    {        this.name=name;    }    public void show()    {        for(int i=0;i<20;i++)            Systme.out.println("name"+name"......"+i);    }}class ThreadDemo{    public static void main(String []args)    {        Demo d1= new Demo("小强");        Demo d2= new Demo("小华");        d1.show();        d2.show();    }}

在之前的代码中，jvm启动后，必然有一个执行路径(线程)从main方法开始的，一直执行到mian方法结束。
这个线程在jvm中称之为主线程。
当主线程在这个程序中执行时，如果遇到了循环而导致在指定位置停留时间过长，
无法执行下面的程序。
可不可以实现一个主线程负责执行其中一个循环，由另一个线程负责其他代码的执行。
实现多部分代码同时执行。
这就是多线程技术可以解决的问题。

该如何创建线程呢？

通过API中的英文Thread的搜索，查到Thread类。

创建线程

有两种方法：

1，继承Thread类

。
1.1定义一个类继承Thread。
1.2重写run方法。
1.3创建子类对象，就是创建线程对象。
1.4调用start方法，开启线程并让线程执行，同时还会告诉jvm去调用run方法。

class Demo extends Thread{    private String name;    Demo(String name)    {        this.name=name;    }    public void run()    {        for(int i=0;i<20;i++)            Systme.out.println("name"+name"......"+i);    }}class ThreadDemo{    public static void main(String []args)    {        //创建了两个线程对象        Demo d1= new Demo("小强");        Demo d2= new Demo("小华");        d2.start();//将d2这个线程开启。        d2.sun();//由主线程负责。        /*            线程对象调用run方法和调用start方法区别？            调用run方法不开启线程，仅是对象调用方法。            调用start开启线程，并让jvm调用run方法在开启的线程中执行。        */    }}

为什么要这么做？
继承Thread类，因为Thread类描述线程事物，具备线程应该有功能。
那为什么不只创建Thread类的对象呢？
Thread t=new Thread();
t.start();//这样没问题，但是该start调用的是Thread类中的run方法，
而这个run方法没有做什么事情，更重要的是这个run方法中并没有定义我们需要让线程执行的代码。

创建线程的目的是什么？
是为了建立单独的执行路径，让部分代码实现同时执行。
也就是说线程创建并执行需要给定的代码(线程的任务)。
对于之前所讲的主线程，它的任务定义在main方法中。
自定义线程需要执行的任务都定义在run方法中。
Thread类中的run方法内部的任务并不是我们所需要，只要重写这个run方法。
既然Thread类已经定义了线程任务的位置，只要在位置中定义任务代码即可。
所以进行了重写run方法动作。

多线程执行时，在栈内存中，其实每一个执行线程都有一片自己所属的栈内存空间，在进行方法的压栈和弹栈。

当执行线程的任务结束了，线程自动在栈内存中释放了。
但是当所有的执行任务都结束，进程就结束了。

获取线程名称
Thread:currentThread()获取当前线程对象，怎么获得名称呢？getName();
Thread.currentThread().getName();

主线程的名称：main
自定义的线程：Thread-1 线程多个时，数字顺延。Thread-2……

2，实现Runnable接口

1.定义类实现Runnable接口，避免了继承Thread类的单继承局限性。
2.覆盖接口中的run方法,将线程任务代码定义到run方法中。
3.创建Thread类的对象，只有创建Thread类的对象才可以创建线程。
4.将Runnable接口的子类对象作为参数传递给Thread类的构造函数。
因为线程已被封装到Runnable接口的run方法中，而这个run方法所属于Runnable接口的子类对象。
所以将这个子类对象作为参数传递给Thread的构造函数，这样，线程对象创建时就可以明确要运行的线程的任务。
5.调用Thread类的start方法开启线程。

class Demo implements Runnable{    private String name;    Demo(String name)    {        this.name=name;    }    //覆盖了接口Runnable中的run方法。    public void run()    {        for(int i=0;i<20;i++)            Systme.out.println("name"+name+"..."+Thread.currentThread().getName()+"......"+i);    }}class ThreadDemo2{    public static void main(String []args)    {        //创建Runnable子类的对象，注意它并不是线程对象。        Demo d= new Demo("Demo");        //创建Thread类的对象，将Runnable接口的子类对象作为参数传递给Thread类的构造函数。        Thread t1=new Thread(d);        Thread t2=new Thread(d);        //将线程启动。        t1.start();        t2.start();    }}

第二种方式实现Runnable接口避免了单继承的局限性，所以较为常用。
实现Runnable接口的方式，更加得符合面向对象，线程分为两个部分，一个部分线程对象，一个部分线程任务。
继承Thread类，线程对象和线程任务耦合在一起，一旦创建了Thread类的子类对象，既有线程对象，又有线程任务。
实现Runnable接口，将线程任务单独分离出来封装成对象，类型就是Runnable接口类型，
Runnable接口对线程对象和任务进行解耦。

通过源码的形式感受一下将runnable接口的子类对象作为参数传递给Thread构造函数的原因。

class Thread{    private Runnable target;    Thread(Runnable target)    {        this.target=target;    }    public void run(){        if(target!=null){            target.run();        }    }    public void start()    {        run();    }}Runnable d=new Demo();Thread t=new Thread(d);