Java多线程

Java多线程：任务并行交替执行

• Thread class -->继承Thread类
  1.自定义线程类继承Thread类
  2.重写run()方法，编写线程体
  3.创建线程对象，调用start()方法启动线程
  4.启动线程：子类对象.start()
  不建议使用：避免OOP(面向对象)单继承局限

然后就形成了这样的输出结果

• Runnable接口
  1.自定义类实现Runnable接口
  2.实现run()方法，编写线程执行体
  3.创建线程对象，调用start()方法启动线程
  4.启动：传入目标对象+Thread对象.start()
  推荐使用：避免了单继承局限性，灵活方便，方便同一个对象被多个线程使用
  
• 线程方法

1.setPriority(int newPriority)		更改线程的优先级
2.static viod sleep(long millis)    让正在执行的线程休眠
3.void join()  						等待该线程终止
4.static void yield()				暂停当前正在执行的线程对象，并执行其他线程
5.void intreeupt()					中断线程(尽量别用这种方式)
6.boolean isAlive()					测试线程是否处于活动状态

• 线程停止
  1.让线程自己停止下来.
  2.建议使用一个标志位进行终止变量当flag=false，则线程停止.
• 线程礼让(yield()方法)
  1.礼让线程，让当前正在执行的线程暂停，但不阻塞
  2.将线程从运行状态转化为就绪状态
  3.让cpu从新调度，礼让不一定成功！看cpu心情
  使用在一个线程之后直接调用yield() 方法即可
• 线程强制执行_join
  1.Join合并线程，待此线程执行完毕后，再执行其他线程，其他线程阻塞
  2.可以想象成插队
  

线程完整状态：

• 同步方法synchronized关键字：
  synchronized:方法控制对象的访问，每个对象对应一把锁，每个synchronized方法都必须获得调用该方法的对象锁才能执行，否则线程会阻塞方法一旦执行就独占该锁，直到该方法返回才释放锁，后面被阻塞的线程才能获得这个锁继续执行.
  **-----------------------缺陷:若将一个大的方法申明为synchronized将会影响效率------------------------------------- **
  synchronized块（同步块）:synchronized(Obj){}，锁的对象是变化的量
  Obj称之为同步监视器
  ***Obj可以是任何对象，但是推荐使用共享资源作为同步监视器
  ***同步方法中无需指定同步监视器，因为同步方法的同步监视器就是this，就是这个对象本身或者是class
  同步监视器的执行过程
  1.第一个线程访问，锁定同步监视器，执行其中代码.
  2.第二个线程访问，发现同步监视器被锁定，无法访问.
  3.第一个线程访问完毕，解锁同步监视器，
  4.第二个线程访问，发现同步监视器没有锁，然后锁定并访问.
• 或者使用CopyOnWriteArrayList来实现线程队列也能保证线程安全
  产生死锁的的四个必要条件：
  1.互斥条件：一个资源只能被一个进程使用。
  2.请求与保持条件：一个进程因请求资源而阻塞时，对方已获得的资源保持不放。
  3.不剥夺条件：进程获得的资源在未使用完成之前，不能强行剥夺。
  4.循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系。
  这四个死锁的必要条件我们只需要想办法破环其中的任意一个或者多个条件就可以避免死锁的发生。
  Lock(锁)
  从JDK5.0开始，Java提供了更强大的线程同步机制——通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当
  java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象
  ReentrantLock类实现了Lock，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁。

public class TestLock {
    public static void main(String[] args) {
        TestLock1 lock1 = new TestLock1();
        new Thread(lock1).start();
        new Thread(lock1).start();
        new Thread(lock1).start();
    }
}
class TestLock1 implements Runnable{
    int ticks=10;
    private final ReentrantLock lock=new ReentrantLock();
    @Override
    public void run() {
        while (true){
            try {
                lock.lock();
                if(ticks>0){
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(ticks--);
                } else {
                    break;
                }
            }finally {
                lock.unlock();
            }
        }
    }
}

• synchronized Lock的对比
  Lock是显式锁（手动开启和关闭锁，别忘记关闭锁) synchronized是隐式锁，出了作用域自动释放
  Lock只有代码块锁,synchronized有代码块锁和方法锁
  使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性(提供更多的子类)
  优先使用顺序:
  Lock >同步代码块（已经进入了方法体，分配了相应资源)>同步方法（在方法体之外)