线程和同步

线程和同步  

线程和进程的区别 

    进程是每次程序运行都会在内存中开辟独立的空间，在这个空间里有线程在执行代码。
    例如：进程是公司 而线程是公司中的程序员，真正执行工作的是程序员。
    cpu切换的线程，多线程提高效率的原因是提高了CPU执行到当前程序线程的概率。    

线程的开启方式

    第一种继承Thread，重写run()方法例如：

        public class MyThread1 extends Thread {
        @Override
        public void run() {
    //        long sa = System.currentTimeMillis();
            Integer a = null;
            for (int i = 0; i < 100000; i++) {
                a = i;
    
            }
    //        long ea = System.currentTimeMillis();
            System.out.println("线程1：" + (ea - sa));
        }
    }

    public class Test11 {
        public static void main(String[] args) {
            MyThread1 myThread1 = new MyThread1();//创建线程对象
            MyThread2 myThread2 = new MyThread2();
            MyThread3 myThread3 = new MyThread3();
            myThread1.start();//开启线程
            myThread2.start();
            myThread3.start();
        }
    }

    

    第二种方式 implement runnable接口 重写run()方法

    public class MyRannable implements Runnable {
    
        @Override
        public void run() {
            for (int i = 0; i < 100; i++) {
                System.out.println(Thread.currentThread().getName() + i);
            }
        }
    }

    public class RannableDemo {
        public static void main(String[] args) {
            MyRannable myRannable = new MyRannable();
            Thread tr = new Thread(myRannable);//最终还是要创建Thread的对象
            tr.start();//通过thread对象开启线程
    
            for (int i = 0; i < 100; i++) {
                System.out.println(i);
            }
        }
    }

start()方法的理解 

    线程Thread对象开启方法 tr.start() 本质实际是是告诉jvm开启一个新的线程，并调用Thread的Thread方法run()方法。查看下run()方法的源码
        public void run() {
            if (target != null) {
                target.run();
            }
        }
    如果有target对象(实际是Runnable的实现类)就执行target的run()方法

 匿名内部类开启线程 

            new Thread() {//相当于创建了thread的子类对象并重写了run()方法
                @Override
                public void run() {
                    for (int i = 0; i < 10; i++) {
                        System.out.println("javaee");
                    }
                }
            }.start();

    相当于new Thread(Runnable的匿名实现类)｛｝

            new Thread(
                    new Runnable() {
                        @Override
                        public void run() {
                            for (int i = 0; i < 100; i++) {
                                System.out.println("javaweb");
                            }
                        }
                    }

            ).start();

两种开启线程的区别

    实现Runnable接口优势
    1，适合去共享同一资源 2，可以避免单继承的局限性 3，增加程序的健壮性，实现了解耦合操作，代码可以被多个线程共享，代码和线程独立分开的 
    4，线程池只能放实现Runnable或Callable的线程，不能放继承Thread的线程

同步 

    多个线程去执行共享资源是容易发生安全性问题。锁机制的引入解决了安全问题，但是降低了程序的执行效率。

    有三种方式解决安全问题
    同步代码块：
    synchronized (Ticket.class) {
    }
    同步方法：
    普通方法时锁对象是this  静态方法时锁是此方法的类的字节码文件
    lock接口锁 用他的实现类 和方法 lock加锁  unlock解锁

线程的状态 

    new 新建的至今未启动状态
    RUNNABLE 正在 Java 虚拟机中执行的线程处于这种状态。
    BLOCKED 受阻塞并等待某个监视器锁的线程处于这种状态。
    WAITING 无限期地等待另一个线程来执行某一特定操作的线程处于这种状态。
    TIMED_WAITING 等待另一个线程来执行取决于指定等待时间的操作的线程处于这种状态。
    TERMINATED 已退出的线程处于这种状态。
#### wait()  notify()  notifyAll()  ####
    1.只能在同步代码块中使用--->会报IllegalMonitorStateException异常
    2.只能当前锁对象才能使用这些方法
    wait()--->使得当前线程处理等待状态
    notify()--->随机唤醒一个当前锁对象所绑定线程,除了自己

    notifyAll()--->唤醒当前锁对象所绑定的所有线程