2.1、线程的两种启动方式

        Thread类：JDK提供好的类，用于表示一个线程对象。实现类Runnable接口

        run()，start()....

        Runnable接口：定义了唯一的一个方法：run()——>线程体

        方法一：直接继承Thread类

                step1：创建一个子类，来继承Thread类

                step2：重写run()方法，因为这是线程体：当CPU调度执行该线程的时候，就要执行的是run()方法中的代码。

                step3：创建该类的对象，表示一个线程，调用start()进而启动这个线程。意味着该线程一切准备就绪，随时可以被CPU调度执行。但是CPU是否立刻执行？不一定，要看CPU自己。

      方法二：实现Runnable接口

            step1：创建一个实现类，实现Runnable接口

            step2：重写run()方法

            step3：先创建该实现类对象：mt，根据实现类对象再创建Thread对象，然后启动。

    Thread类的构造方法：

            Thread();//创建一个线程对象，执行run()。线程的默认名：Thread-0,1,2...

            Thread(Runnable target);//创建一个线程对象，指明了target，执行的run是Runnable接口中。

            Thread(String name);//创建一个线程，并给起个名字

            Thread(Runnable target,String name);

对比两种创建并启动线程的方式：

2.2、线程的常用方法

    关于Thread类的常用方法：

            1、获取当前的线程对象：由Thread类直接调用，获取当前正在被执行的那个线程

                    staticThreadcurrentThread() ;//返回对当前正在执行的线程对象的引用。  

            2、线程的名字：当一个线程创建的时候，如果没有设置名称：构造方法设置，或者setName()设置。系统默认的：Thread-0,Thread-1,Thread-2......

                    StringgetName()

                        返回此线程的名称。

                    voidsetName(Stringname)

                        将此线程的名称更改为等于参数name。

            3、线程的Id：每个线程创建的时候，由系统自动分配一个Id，long类型的数值，终身不变。从线程的出生到死亡。

                    该Id值，由系统自动分配，程序员无法手动操作。

                        longgetId()

                        返回此线程的标识符。

            4、线程的优先级：priority

                        System.out.println("最大优先级："+Thread.MAX_PRIORITY);//10

                        System.out.println("最小优先级："+Thread.MIN_PRIORITY);//1

                        System.out.println("正常优先级："+Thread.NORM_PRIORITY);//5

            当一个线程被创建的时候，由系统自动分配一个优先级，固定都是正常优先级：5

           但是程序员可以根据需求，手动调整线程的优先级。

                intgetPriority()

                        返回此线程的优先级

                voidsetPriority(intnewPriority)

                        更改此线程的优先级。

注意：容易误解为：优先级别高的先执行，然后再执行优先级低的。大大的错误XXXXX

        优先级别高，被CPU调度执行的机会就多。但是不绝对。

        优先级别低，被CPU执行的机会就少，但是也不绝对。

5、线程的睡眠：重要的方法

        staticvoidsleep(longmillis)

            使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行），具体取决于系统定时器和调度程序的精度和准确性。

            静态方法，应该由类直接调用，对象也可以调用

    注意：不是谁调用就谁睡，而是当前正在执行的线程进入睡眠了。和谁调用无关。

6、线程合并

        voidjoin()

            等待这个线程死亡。

        t1线程，t2线程，main线程

        t1,t2,main--->3条线程抢占资源

                某一个时刻：main线程中：t1.join()，主线程要等待t1线程死亡之后再执行

        t1，t2--->2条线程抢占资源，main等

        t1结束后，main线程再执行

        阻塞：

                Scannerscan=newScanner(System.in);

                    scan.nextInt();//阻塞式。等--->解除阻塞，读取到一个键盘输人

7、守护线程

        setDaemon();

                为前台线程服务，如果所有的前台线程都结束了，那么守护线程也就结束了。

                GC：垃圾自动回收机制。JVM启动后，创建主线程执行main()的时候。。。随之而创建并启动的还有很多后台线程，比如gc()

2.3、线程的状态

        线程的生命周期：5种，6种，7种。

        线程的一生，就好比秀女的一声。

        线程new出来：新建

        准备就绪，启动：start：就绪状态

        如果被CPU调度执行：运行状态，run()方法

        阻塞状态：-->进入就绪

        出生-->就绪-->运行-->死亡

2.4、临界资源的安全问题

        多个线程访问共享的数据，临界资源。

        多个线程之间存在共享的数据。一条线程执行过程中，其他线程也可以访问，可能会修改数据的值。造成的共享数据的不安全。叫做临界资源的安全问题。

2.5、同步synchronized

        同步：原子性操作。同步起来的代码，一次只能被1个线程执行完毕，这个过程中，不能被其他的线程插入执行。

        同步的原理：

            对象的"互斥锁"。每个对象都可以看做一个锁。有两种状态：打开(默认)，关闭。

            锁对象：多条线程功能访问的同一个对象。

            t1，t2，t3，t4--->共同的一把锁头(同一个对象)

同步的方式一：同步代码块

        synchronized(锁对象){//上锁

                //被同步的代码，每次只能被一个线程执行，中间不能被其他线程插入执行

        }//锁打开

注意点：

        同步的原理：锁定一个对象。(对象可以和程序无关，但必须是多个线程访问的共同的对象才可以)。

    常用的锁对象：

            this，创建一个对象，传入进去。

            大招：类名.class，字符串常量："abc"

同步的方式二：同步方法

    //该方法，每次只能有一个线程来执行，期间，不能被其他的线程插入执行。

        publicsynchronizedvoid方法名(){

        }

    同步的优缺点：

        解决了多线程之间的共享数据的安全问题

        降低效率，容易死锁。

死锁：多个线程互相持有对象，僵持的现象。

    解决死锁：

        1、减少成员变量的使用。

        2、加大锁的粒度。不要锁小对象，锁大对象。