java多线程

一.1.一个程序运行后至少有一个进程，一个进程中可以包含多个线程，但至少有一个线程。
2.多线程运行原理：在某一时刻，只会运行一个进程。由于CPU(中央处理器)在做着高速的切换而导致的。对于CPU(中央处理器)而言，它在某个时间点上，只能执行一个程序，CPU(中央处理器)不断地在这些进程之间切换。
同步锁：当任何线程进入锁标识的这段代码时，首先都会先判断目前有没有线程正在使用锁标记对象，若有线程正在使用这个标记对象， 那么当前这个线程就在锁标识的外面等待，直到前一个执行完这个标记对象后，这个线程才能执行同步代码块。
3必然有一个执行路径(线程)从main()方法开始的。一直执行到main()方法结束。这个线程在java中称之为主线程.多线程可以解决一个主线程负责执行其中一个循环，由另一个线程负责其他代码的执行。
4.线程对象调用 ==run()方法==和调用==start()==方法区别:
线程对象调用run方法不开启线程。仅是对象调用方法。线程对象调用start开启线程，并让jvm调用run方法在开启的线程中执行。
5.实现Runnable的好处
第二种方式实现==Runnable==接口避免了单继承的局限性，所以较为常用。实现==Runnable==接口的方式，更加的符合面向对象，线程分为两部分，一部分线程对象，一部分线程任务。
6.线程的五大状态分别为：
（1）新建状态：即单纯地创建一个线程，创建线程有三种方式。
（2）就绪状态：在创建了线程之后，调用==Thread类==的==start()==方法来启动一个线程，即表示线程进入就绪状态！

（3）运行状态：当线程获得CPU时间，线程才从就绪状态进入到运行状态！

（4）阻塞状态：线程进入运行状态后，可能由于多种原因让线程进入阻塞状态，如：调用==sleep()==方法让线程睡眠，调用==wait()==方法让线程等待，调用==join()==方法、==suspend()==方法（它现已被弃用！）以及阻塞式IO方法。

（5）死亡状态：==run()==方法的正常退出就让线程进入到死亡状态，还有当一个异常未被捕获而终止了==run()==方法的执行也将进入到死亡状态！
其实是六个状态： NEW： 创建一个线程，尚未启动的线程 。RUNNABLED： 就绪状态，等待来自操作系统的分配资源 。BLOCKED： 阻塞，尝试获取Synchronized锁失败或者被唤醒以后还没获取锁的时候。 WAITING： 等待，调用了wait、sleep、join、park方法的时候，并且没超时。 TIMED_WAITING： 超时等待。 TERMINATED： 终止，线程已经完成执行。

5.3、线程方法

二.创建线程方式一：继承Thread类
创建线程的步骤：
1. 定义一个类继承Thread。
2.重写==run()方法==。
3. 创建子类对象，就是创建线程对象。
4. 调用==start()方法==，开启线程并让线程执行，同时还会告诉jvm去调用==run()方法==。
class Demo extends Thread  //继承Thread
{
    String name;
    Demo(String name)
    {
        this.name = name;
    }
    //复写其中的run方法
    public void run()
    {
        for (int i=1;i<=20 ;i++ )
        {
            System.out.println("name="+name+",i="+i);
        }
    }
}
class ThreadDemo 
{
    public static void main(String[] args) 
    {
        //创建两个线程任务
        Demo d = new Demo("小强");
        Demo d2 = new Demo("旺财");
        //d.run(); 这里仍然是主线程在调用run方法，并没有开启两个线程
        //d2.run();
        d2.start();//开启一个线程
        d.start();//主线程在调用run方法
    }
}
创建线程方式二：实现Runnable接口
1. 定义类实现==Runnable接口==。
2. 覆盖接口中的==run()方法==。
3. 创建==Thread类==的对象。
4. 将==Runnable接口==的子类对象作为参数传递给==Thread类==的构造函数。
5. 调用==Thread类==的==start()方法==开启线程。
class Demo implements Runnable
{
    private String name;
    Demo(String name)
    {
        this.name = name;
    }
    //覆盖了接口Runnable中的run方法。
    public void run()
    {
        for(int i=1; i<=20; i++)
        {            System.out.println("name="+name+"..."+Thread.currentThread().getName()+"..."+i);
        }
    }
}
class ThreadDemo2 
{
    public static void main(String[] args) 
    {
        //创建Runnable子类的对象。注意它并不是线程对象。
        Demo d = new Demo("Demo");
        //创建Thread类的对象，将Runnable接口的子类对象作为参数传递给Thread类的构造函数。
        Thread t1 = new Thread(d);
        Thread t2 = new Thread(d);
        //将线程启动。
        t1.start();
        t2.start();
        System.out.println(Thread.currentThread().getName()+"----->");
        System.out.println("Hello World!");
    }
}
创建线程方式二：实现Callable接口创建线程
（1）自定义一个类==MyThread==，实现Callable接口并覆写==Callable接口==的==call()==方法。

（2）利用MyThread类实例化Callable接口的对象。

（3）利用FutureTask类的构造方法public FutureTask(Claaable<V> callable)，将Callable接口的对象传给FutureTask类

（4）将FutureTask类的对象隐式地向上转型，从而作为Thread类的public Thread(Runnable runnable)构造方法的参数

（5）这样就建立了Callable接口与Thread类之间的关系，再调用Thread类的start()方法。有返回值

同步锁加到run()中：
//接口Runnable
class suo implements Runnable{
static  int s=300;//总钱数s
//设置锁为lock
static Object lock=new Object();
//重写run方法
    @Override
    public void run() {
    while (true) {
//synchronized设置锁
        synchronized (lock) {
            if (s>0){
                s--;
            System.out.println(Thread.currentThread().getName() + "..." + s);
        }
        }
    }
    }
    public static void main(String[] args) {
//创建class的对象。class 对象名=new class();
suo q=new suo();
//设置线程1     Thread 线程名=new Thread(对象名);
        Thread a=new Thread(q);
//设置线程2
        Thread b=new Thread(q);
//启动线程  线程名.start();
a.start();
b.start();
    }
}

同步锁加到方法：
class bank2 implements Runnable{
private int money;
private Object lock=new Object();
public synchronized void add(int num){
    synchronized (lock){ money+=num;System.out.println(Thread.currentThread().getName()+"..."+money); } }
    @Override
    public void run() 
{ while (true){ if(money<1000){ add(100); } } }
        public static void main(String[] args) {
        bank2 bank=new bank2();
        Thread s1=new Thread(bank,"窗口1");
        Thread s2=new Thread(bank,"窗口2");
        s1.start();s2.start();
    }
}

线程休眠：指的是让线程暂缓执行，等到预计时间之后再恢复执行。

将线程暂时转为阻塞状态，执行其他线程，sleep（有时间）结束时才能转为就绪状态，期间循环时CPU不可能执行这个线程

线程让步：调用==yield()==方法让当前线程交出CPU权限，让CPU去执行其他线程 

将线程转为就绪状态 ，cpu执行其他线程，再次循环时有可能再次执行

等待线程终止：指的是如果在主线程中调用该方法时就会让主线程休眠，让调用==join()==方法的线程先执行完毕后再开始执行主线程。