线程

一:建立线程

建立线程的方式分为两种
一是通过继承Thread
二是通过实现Runnable接口
两种方法推荐使用实现Runnable接口方法
因为java不允许多重继承但是支持多次调用接口也就是所谓的
单继承多实现

//方法一:继承Thread
//创建一个Thread类的子类
 MyThread myThread = new MyThread();
 //开启线程
 myThread.start();

方法二:实现Runnable接口
        //1:创建一个XXRunnable对象
        MyRunnable myRunnable = new MyRunnable();
        //2:创建一个Thread对象
        //并将上面创建的XXRunnable对象传入构造方法
        //target是Runnable接口类型
        //可以接收实现了Runnable接口的任何一个类的对象
        //经常说成:它(指的就是Runnable接口)的实现类对象
        Thread t1 = new Thread(myRunnable);
        t1.start();

除上述两种方法外还有两种简便的创建线程的写法
叫做匿名对象+匿名内部类

//实现Runnable接口
new Thread(new Runnable() {
            @Override
            public void run() {
               while (true){
                   System.out.println("我是第一个线程");
               }
            }
        }).start();
        //调用.start()的方法开启线程

//继承Thread
new Thread(){
            @Override
            public void run() {
                super.run();
                while (true){
                    System.out.println("/");
                }
            }
        }.start();

线程是抢占式运行, 谁抢到了cpu的执行权,那么谁就执行

线程的生命周期

线程的生命周期分为
新建状态:(New）：新创建了一个线程对象,只分配的内存

就绪状态:(Runnable/ready）：线程对象创建后，其他线程调用了该对象的start()方法。该状态的线程位于可运行线程池中，变得可运行，等待抢占CPU的使用权。注意!只有进入就绪状态线程才可以进入运行状态

运行状态:（Running) : 就绪状态中的线程抢到了cpu的使用权,并开始运行程序代码

阻塞状态:（Blocked）：阻塞状态是线程因为某种原因放弃CPU使用权，暂时停止运行。直到线程进入就绪状态，才有机会转到运行状态。阻塞的情况分三种：
（一）、等待阻塞：运行的线程执行wait()方法，JVM会把该线程放入等待池中。
（二）、同步阻塞：运行的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM会把该线程放入锁池中。
（三）、其他阻塞：运行的线程执行sleep()或join()方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。

死亡状态:（Dead）：线程执行完了或者因异常退出了run()方法，该线程结束生命周期。

sleep()方法
sleep（…毫秒），指定以毫秒为单位的时间，使线程在该时间内进入线程阻塞状态，期间无法抢占cpu的使用权，等到时间过去了，线程重新进入可执行状态(可以去抢cpu的使用权)（暂停线程，不会释放锁）

wait（）和notify（）方法
两个方法搭配使用，wait（）使线程进入阻塞状态，调用notify（）时，线程进入可执行状态.wait（）内可加或不加参数，加参数时是以毫秒为单位，当到了指定时间或调用通知（）方法时，进入可执行状态。
wait（）所等待的对象必须先锁住

join（）方法
join也叫线程加入,是当前线程甲调用另一个线程乙的加入（）方法，使当前线程转甲入阻塞状态，直到线程乙运行结束，线程甲才由阻塞状态转为可执行状态。（）内可加或不加参数，加参数时是以毫秒为单位
当到了指定时间执行线程乙,线程乙执行完毕之后,开始继续执行线程甲

锁

锁的关键字synchronized
锁是什么?
锁是一个对象
假如A线程先访问这个del方法,
那么锁对象就会被A线程持有
其他线程(b,c,d)就都不能进入到del方法中
当a线程执行完毕del方法,会将锁对象释放出来
这时候(b,c,d)线程再争夺执行权
谁抢到了,谁来执行del方法
谁执行del方法,那么谁就又先行拿到了锁对象
这时候剩下的两个线程就又进不来del方法中了

使用synchronized关键字的两种方式:
1:在方法声明上,使用synchronized关键字修饰
2:使用synchronized代码块将要执行的代码包起来

 public synchronized void del(){
 各种代码
 }

 public  void del1() {
  synchronized (this){
  各种代码
   }
 }

而第一个线程已经进入了del方法
也就持有了锁对象
第二个线程,想要进入show方法
需要等第一个线程从del方法中出来,释放锁对象的时候
才能进入show方法中
任何包装类都可以是锁

同步 异步

  showSynchronized,表示同步的意思
  比如小明要和小红一起去吃饭,
  小红说你等我化个妆,然后再一起去
  小明等了三个小时
  然后俩人一起去吃饭了

 同步:就是你做了这件事情,必须做完才能做下一件事情
 同步:可理解为等待某一事件,结束了才能开始做下一件事情
 异步:就是做了一件事情没做完,就可以去做别的事情了