线程实现方式。

并发与并行：

并发:多个任务交替执行 （一个人吃两个馒头，两个交替啃）

并行：同时执行。（n个人吃n个馒头）  速度快些。

线程与进程：

进程：进入到内存中的程序叫进程。

线程：

 主线程：

执行主方法（main）的线程

单线程程序：java程序中只有一个线程，从main方法开始，从上到下依次执行。

jvm执行main方法，main方法会进入栈内存，

然后jvm找到操作系统开辟一条main方法通向cpu的执行路径，

cpu就可以通过这个路径执行main方法，这个路径叫main（主）线程。

多线程：

java程序属于抢占式调度，哪个线程高，哪个线程就优先执行，同一级别随机执行。

创建多线程程序的第一种方式：

java.lang.thread 类：是描述线程的类，想实现多线程程序，就必须继承该类。

实现步骤：　

　　1、创建thread类的子类。

　　2、子类重写run方法， 来设置线程任务。

　　3、创建子类对象，调用start（）方法，开启新的线程，执行run方法。

　　结果是：两个线程并发执行。

public class mythread extends thread {
    @override
    public void run() {
        for (int i=0;i<3;i++){
            system.out.println("run->"+i);
        }
    }
}

public class threaddemo {
    public static void main(string[] args) {
        mythread mythread=new mythread();
        mythread.start();
        for (int i=0;i<3;i++){
            system.out.println("main->"+i);
        }
　　　　main->0
　　　　run->0
　　　　main->1
　　　　run->1
　　　　main->2
　　　　run->2
    }
}

多线程运行原理：

new mythread的时候，又开辟了一条通向cpu的新路径，来执行run方法。

此时，对cpu而言，就有了两条执行路径。

main线程和新线程一起抢夺cpu的执行权。

多线程内存分析：

开始执行程序时，开辟一块栈内存，main方法入栈。

此时，如果直接调用run方法的话，也是在这块栈内存执行run（），也就是仍然

是main线程程序（单线程）程序。

而如果调用的是start（），会另外开辟一块栈空间，run（）入栈执行。

thread类的常用方法：

获取线程名称：

　　1、thread类的方法，getname（）；

　　2、获取当前正在执行的线程 static thread currentthead(),然后用getname();

第一种：

public class mythread extends thread {
    @override
    public void run() {
        system.out.println(getname());
        }
    }

public static void main(string[] args) {
        new mythread().start();
        new mythread().start();
        //thread-0
       // thread-1
    }

第二种：

public static void main(string[] args) {
        system.out.println(thread.currentthread().getname());
        //main
    }
}

设置线程名称：

　　1、void setname(string name) 2、设置带参构造函数

sleep方法：

　　public static void sleep(long ...) :使当前正在执行的线程以指定毫秒暂停。

 public static void main(string[] args) {
       for (int i=0;i<5;i++){
           system.out.println(i);
           try {
               thread.sleep(1000);
           } catch (interruptedexception e) {
               e.printstacktrace();
           }
       }
    }

创建多线程程序的第二种方式：

实现runnable接口：

java.lang.runnable.   实现类必须定义run的无参方法。

java.lang.thread 类的构造方法：

　　1、thread(runnable target) 分配新的thread对象。

　　2、thread(runnable target,string name)。

实现步骤：

　　1、创建runnable接口的实现类。

　　2、重写run方法，设置线程任务。

　　3、创建实现类的对象，用含有runnable接口的构造函数创建thread类对象。

　　4、用start方法，开启新线程执行run（）；

public class runnableclass implements runnable {
    @override
    public void run() {
        for (int i=0;i<5;i++){
            system.out.println(
                    thread.currentthread().getname()
                    +"->"+i
            );
        }
    }
}

public static void main(string[] args) {
       runnableclass runnable=new runnableclass();
       thread thread=new thread(runnable);
       thread.start();
       for (int i=0;i<5;i++){
           system.out.println(
                   thread.currentthread().getname()
                   +"->"+i
           );
       }
    }

两种实现多线程方法的区别：

实现runnable接口实现多线程的好处：

　　1、避免单继承的局限性：　

　　　　继承了thread类就不能继承其他类了，而使用接口的方式还可以继承其他类。

　　2、增强程序的扩展性，降低了程序的耦合性（解耦）：

　　　　用实现runnable接口的方式，把设置线程任务和开启线程进行分离（解耦 ）

匿名内部类实现多线程：

作用：

　　简化代码，把实现类实现接口，重写方法，创建实现类方法统一完成。

格式：　　new 父类/接口（）{重写方法}；

 public static void main(string[] args) {
        new thread() {
            @override
            public void run() {
                for (int i=0;i<5;i++){
                    system.out.println(currentthread().getname());
                }
            }
        }.start();
       new thread(new runnable() {
           @override
           public void run() {
               for (int i=0;i<5;i++){
                   system.out.println(thread.currentthread().getname());
               }
           }
       }).start();
    }