Java多线程机制详解

一.创建线程的两种方式

1.继承Thread

class MyThread extends Thread{

    private static int ticket = 10;
    private String name;
    public MyThread(String name){
        this.name =name;
    }

    public void run(){
        while(this.ticket>0){
            System.out.println(this.name+"卖票---->"+(this.ticket--));
        }
    }
}

2.实现Runnable接口

class MyThread implements Runnable{  
    private int ticket =10;  
    private String name;  
    public void run(){
        while(this.ticket>0){
            System.out.println(this.name+"卖票---->"+(this.ticket--));
        }
    }
}  

二.线程的5种状态

1.新生状态（创建状态）。在生成线程对象，但是没有调用对象的start()方法时，该线程处于创建状态
2.就绪状态。当调用了线程对象的start方法之后，该线程就进入了就绪状态，此时线程具有CPU的执行资格，但是没有CPU的执行权。
3.运行状态。线程调度程序将处于就绪状态的线程设置为当前线程，开始运行run函数当中的代码，此时线程就进入运行状态，处于运行状态的线程既有CPU的执行资格，又有CPU的执行权。
4.阻塞状态。线程正在运行的时候，被暂停，通常是为了等待某个时间的发生(比如说某项资源就绪)之后再继续运行。sleep，suspend，wait等方法都可以导致线程阻塞。此时线程既没有CPU的执行资格，也没有CPU的执行权。
5.死亡状态。如果一个线程的run方法执行结束或者调用stop方法后，该线程就会死亡。对于已经死亡的线程，无法再使用start方法令其进入就绪转态。

• sleep()与wait()的区别？
  如果当前线程进入了同步锁，调用sleep()方法并不会释放锁，其他被同步锁挡住了的线程也无法得到执行，在sleep()指定的时间过后，线程会自动回到就绪状态等待CPU的执行；而wait()方法会释放同步锁，以便其他正在等待此锁的线程可以得到同步锁并运行，只用其他线程调用了notify()或notifyAll()方法，线程才会回到就绪状态。但是notify()方法并不释放同步锁，只是告诉调用过wait()方法的线程去参与同步锁的竞争，但不是马上得到锁，因为锁在别人手里，别人还没释放。

三.线程的同步

• 同步与异步有何不同，在什么情况下使用它们？
  如果数据在多个线程之间共享并且操作共享数据的代码不止一条时，就需要对共享数据进行同步处理，即某一个线程在操作共享数据时，其他线程无法操作，只到该线程释放共享数据。当应用程序调用一个需要花费很长时间来执行的方法，并且不需要等待返回结果时，就采取异步操作，例如：下载资源。

• 同步的好处和弊端？
  好处：解决了线程的安全性问题
  弊端：降低了效率，因为同步外的线程都要判断同步锁

1.同步代码块

思路：将操作共享数据的多条代码封装起来

package com.ghs.sort;

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();
        t2.start();
        t3.start();
        t4.start();
    }
}

class Ticket implements Runnable{
    int num=100;    //所有的线程共用一个num对象
    Object obj = new Object();
    public void run(){
        while(true){
            synchronized(obj){
                if(num>0){
                    System.out.println(Thread.currentThread().getName()+"......sale......"+num--);
                }
            }
        }
    }
}

同步锁就相当于一个标志位，初始值为1，有线程进去了，值就变为0，只有当同步锁为1的时候，其他线程才能进去。

2.同步函数

public class Demo {
    public static void main(String[] args) {
        BankRun br = new BankRun();
        Thread t1 = new Thread(br);
        Thread t2 = new Thread(br);
        t1.start();
        t2.start();
    }
}

class BankRun implements Runnable {
    Bank b = new Bank();
    public void run() {
        b.add(100);
    }
}

class Bank {
    private int sum;
    //模拟存钱的过程
    public synchronized void add(int num) { //此处存在安全问题,采用同步函数来解决
        sum = sum + num;
        System.out.println(Thread.currentThread() + "......Total=" + sum);
    }
}

注意：
1. 同步函数的锁是this
2. 静态同步函数的锁是Class对象而不是this，因为静态函数没有所属的对象

当一个线程进入一个对象的synchronized方法后，其他线程是否可以进入此对象的其他方法？
1. 其他方法前如果不是synchronized方法，则能进入。
2. 如果这个方法内部调用了wait，则能进入其他的synchronized方法。
3. 其他方法如果都加了synchronized，并且内部没有调用wait，则不能进入。
3. 如果其他方法是static，它的同步锁是当前类的字节码，与非静态方法不能同步，所以能进入。