多线程之 1.初识多线程

1.1线程&进程

进程：就是应用程序在内存中分配的空间，（正在运行中的程序）,一个进程可以包含多个线程。
线程：是进程中负责程序执行的执行单元，也叫执行路径。
一个进程中至少有一个线程在负责该进程的运行。如果一个进程中出现了多个线程，就称该程序为多线程程序。

1.2并行&并发

并行：多个CPU同时执行多个线程
并发：单个CPU来回切换执行多个线程

1.3实现多线程

方式一

(1)定义类继承Thread类，重写run()方法。创建线程对象，调用start()方法运行。
例子：

  class MyThread extends Thread{
    
        @Override
        public void run() {
            for (int i = 0; i < 15; i++) {
                System.out.println(
                        "hello , This is a thread method , name is "
                                +Thread.currentThread().getName()+" "+i
                );
            }
        }
    }
    public class 初识多线程 {
        public static void main(String[] args) {
        
            MyThread myThread = new MyThread();
            Thread thread1 = new Thread(myThread,"myThread");
            thread1.start();
        }
    }

方式二

(2)实现Runnable接口，重写run()方法。创建线程对象Thread(实现类对象)，调用start()方法运行。
例子：

    class MyRunnable implements Runnable {
    
        @Override
        public void run() {
            for (int i = 0; i < 15; i++) {
                System.out.println(
                        "hello , This is a thread method , name is "
                                +Thread.currentThread().getName()+" "+i
                );
            }
        }
    }
    public class 初识多线程 {
        public static void main(String[] args) {
        
            MyRunnable runnable = new MyRunnable();
            Thread thread2 = new Thread(runnable,"myRunnable");
            thread2.start();
        }
    }

1.4常用方法

    public  String  getName()   :获取当前线程名称。
    public  void    start() :导致此线程开始执行; Java虚拟机调用此线程的run方法。
    public  void    run()   :此线程要执行的任务在此处定义代码。
    public  static  void    sleep(long millis)  :使当前正在执行的线程以指定的毫秒数暂停
    public  static  Thread  currentThread() :返回对当前正在执行的线程对象的引用

1.4.1构造方法

    public Thread() :分配一个新的线程对象。 
    public Thread(String name) :分配一个指定名字的新的线程对象。 
    public Thread(Runnable target) :分配一个带有指定目标新的线程对象。 
    public Thread(Runnable target,String name) :分配一个带有指定目标新的线程对象并指定名字

例子：

    public static void main(String[] args) {
        try {
        MyThread myThread = new MyThread();
        Thread thread = new Thread(myThread,"myThread");
    //        Java虚拟机调用此线程的run方法
        thread.start();
    //        获取当前线程名称 myThread
            String name = thread.getName();
            System.out.println("name = " + name);
            //使当前正在执行的线程以指定的毫秒数暂停     1秒
            Thread.sleep(1000L);
        System.out.println("结束");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

1.5实现Runnable接口的利弊：

利：
(1)避免了继承Thread类的单继承的局限性。
(2)丰富和面型对象编程的思想，将线程对象单独封装。
(3)降低了线程对象和线程任务的耦合性。
弊：
代码复杂需要先获取线程对象

1.6用匿名内部类实现两种方式

继承Thread：

    public static void main(String[] args) {
        new Thread() {
            @Override
            public void run() {
                for (int i = 1; i < 11; i++) {
                    System.out.println(Thread.currentThread().getName());
                }
            }
        }.start();
    }

实现Runnable：

    public static void main(String[] args) {
        new Thread(new Runnable() {
            int i = 0;
            @Override
            public void run() {
                for (int a = 0; a < 11; a++) {
                    System.out.println(i++);
                }
            }
        }).start();
    }