Java多线程（1）

    1.首先我们明确一下进程和线程的概念：简单地说，进程就是是一个正在执行的程序，是一个动态的概念。每一个进程执行都有一个执行顺序，该顺序是一个执行路径，或者叫一个控制单元。而线程就是进程中的一个独立的控制单元，即线程在控制着进程的执行。每一个进程至少拥有一个线程。

    Java VM 启动的时候会有一个进程java.exe，该进程中至少有一个线程负责java程序的执行，而且这个线程运行的代码在main()方法中，该线程称为主线程。Java 虚拟机(virtual machine)允许应用程序并发地运行多个执行线程。

扩展：其实更细节说明Java VM，Java VM启动不止一个线程，还有负责垃圾回收机制的线程。

    2.在Java中创建新执行线程有两种方法，一种方法是将类声明为Thread的子类，该子类重写Thread类的run方法。接下来可以分配并启动该子类的实例（调用Thread类的start()方法，才是真是启动了该线程）。为什么要重写run()方法呢？Thread类用于描述线程，该类定义了一个功能，用于存储线程要运行的代码，该存储功能就是run()方法。也就是说Thread类中的run()方法，用于存储线程要运行的代码。

    那么多个线程是不是同时在执行呢，假设是单核CPU，且在Windows中？Windows是多任务操作系统，CPU在不断地切换每一个进程的线程，或者一个进程中的多个线程。CPU的切换速度非常快，让我们感觉很多程序在同时执行。准确地说，在某一个时刻，只有一个线程在执行（多核除外）。多线程的一个特性：随机性，谁抢到谁执行，至于执行多久，看CPU。

    线程的几个状态间的转换：被创建—start()—>运行—sleep(time)—>冻结（sleep时间到恢复到运行或阻塞状态，放弃了执行资格），运行—wait()—>冻结—nofity()—>运行—stop()或run()方法结束—>消亡，运行<——>阻塞（临时状态，等待CPU执行权，即该线程具有运行资格，但是没有执行权）

    第二个创建线程的方法是：声明实现Runnable接口的类，该类然后实现run()方法，然后可以分配该类的实例，在创建Thread时作为一个参数来传递并启动。

    实现方式和继承方式有什么不同？Java中只能单继承，但可以多实现。实现方式避免了单继承的局限性，在定义线程时，建议使用实现方式。两种方式的线程代码（run()）存放的位置不同。

    3.多线程存在的安全问题：

 

/* 
 通过运行，分析，发现会打印出0，-1，-2等错票
 多线程的运行出现了安全问题。
 问题的原因：
    当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完，另外一个线程参与进来，导致共享数据的错误。
 解决方法：
     对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可以参与执行。
*/
class Ticket implements Runnable {

    private int ticket = 100;// 共享变量
     
    public void run() {
        
        while(true) {
            
            try{
                 Thread.sleep(10);
            }catch(exception e) {
               
             System.out.println(Thread.currentThread().getName() + " sale" + ticket);
             }
        }
    }
}

public class Demo {

    public static void main(String[] args) {
        Ticket t = new Ticket();
         
        Thread t1 = new Thread(t);
        Thread t2 = new Thread(t);
        Thread t3 = new Thread(t);
        Thread t4 = new Thread(t);
        
        t1.start();
        t1.start();
        t1.start();
        t1.start();
    }
}

 

    Java对此提供了解决方式：（1）同步代码块

 

synchronized(对象)
{
    需要被同步的代码
}
// 这个对象如同锁，持有锁的线程可以在同步代码中执行，没有持有锁的线程即使
//获取CPU的执行权，也进不去同步代码中。

    同步的前提：1.必须要有两个或两个以上的线程。2.必须是多个线程使用同一个锁。3.有些代码需要同步，有些不需要。同步的好处：解决了多线程的安全问题。坏处：每次进入同步代码块，都需要判断一下锁的状态，会消耗一定的资源。

    如何找到安全问题：（1）明确哪些代码是多线程运行代码（2）明确共享数据是谁（3）明确多线程运行代码中哪些语句是操作共享数据的。

  （2）同步函数：用synchronized来修饰函数，同步函数的锁是this。 静态同步函数的锁是Class对象（字节码文件对象：类名.class），因为静态方法中也不可以定义this。静态（函数或变量）进内存时，内存中还没有本类对象，但是一定有该类对应的字节码文件对象。类名.class，该对象的类型是Class。

    同步的一个弊端——死锁：同步中嵌套同步，但是锁却不同。

/* 下面的例子有可能会产生死锁。 LockTest.java */

class MyLock {  // 创建两个锁
    static Object lockA = new Object();
    static Object lockB = new Object();
}

class Test implements Runnable {
    private boolean flag;
    
    public Test(boolean flag) {
        this.flag = flag;
    }
    if (flag) {
        synchronized(MyLock.lockA) {
            System.out.println("if lockA")
            synchronized(MyLock.lockB) {
                 System.out.println("else lockB");
            }
        }    
    }else{
         synchronized(MyLock.lockB) {
            System.out.println("if lockB")
            synchronized(MyLock.lockA) {
                 System.out.println("else lockA");
            }    
     }

}


public class LockTest {
     
    public static void main(String[] args) {
        Thread t1 = new Thread(new Test(true));
        Thread t2 = new Thread(new Test(flase));
         t1.start();
         t2.start();
    }
}