java 线程

1.什么是线程？

线程是程序执行的一条路径，一个进程可以包含多个线程

2.多线程的好处：多线程的并发可以极大的提高程序的效率，可以同时完成多项工作

3.JVM是多线程的吗？答案：是，因为jvm运行时至少启动了垃圾回收线程和jvm主线程两条线程

4.如何开启线程 ★★★★★：

1）新建一个类并继承Thread类，重写父类的run()方法（非必需）。实例化该对象并调用start()方法就可以开启一个新的线程。如下：

public class Thread_Demo {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start();
        for(int i = 10; i < 1000; i++){
            System.out.println("main thread is running");
        }       
    }
}
class MyThread extends Thread{
    @Override
    public void run() {
        for(int i = 10; i < 1000; i++){
            System.out.println("thread 1 is running");
        }
    }
}

2)实现runnable接口并重写run方法（必须重写），然后实例化一个Thread对象，将这个runnable的实现类作为参数传递并调用thread的start方法，如下：

public class Thread_Demo {
    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();
        Thread thread = new Thread(myRunnable);
        thread.start();
        for(int i = 10; i < 1000; i++){
            System.out.println("main thread is running");
        }

    }
}
class MyRunnable implements Runnable{

    public void run() {
        for(int i = 10; i < 1000; i++){
            System.out.println("runnable 1 is running");
        }
    }
}

继承Thread和实现runnable的区别：

1）继承Thread，可以直接使用Thread的方法，但是不适用于类已经存在父类的情况

2）实现Runnable，接口是可以多实现的，但是不能直接使用thread中的方法
 

Thread的几个主要方法：

1）getName()；获取当前线程的名称，如果不设置，名称默认为1，2，3，4....

可以公国setName();或者通过构造函数赋值

2）静态方法currentThread(),获取当前正在执行的线程，如下

class MyRunnable implements Runnable{
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}

3)静态方法sleep(ms),休眠线程，使线程中断N毫秒，需要抛出终端异常。N毫秒后，线程会自动唤醒。

4）守护线程setDaemon(),该线程不会单独执行，只有其他非守护线程都执行完成之后，这个线程会自动退出。（比如说象棋中的帅就是非守护线程，而其他的棋子就是守护线程，当帅挂了，其他棋子随之停止）

5）加入线程join();插队执行，即执行thread2的时候thread1插队进来执行。

final Thread thread1 = new Thread(){
    @Override
    public void run() {
        System.out.println("I am thread1");
    }
};
Thread thread2 = new Thread(){
    @Override
    public void run() {
        System.out.println("I am thread2");
        try {
            thread1.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
};
thread1.start();
thread2.start();

6）礼让线程：静态方法yield(),让出当前线程的时间片，但是会继续执行，与其他线程竞争cpu时间片，看不出多大区别

final Thread thread1 = new Thread(){
    @Override
    public void run() {
        System.out.println("I am thread1");
    }
};
Thread thread2 = new Thread(){
    @Override
    public void run() {
        System.out.println("I am thread2");
        Thread.yield();
    }
};
thread1.start();
thread2.start();

7）关键字synchronized（对象的引用）可以修饰代码块或者方法。用于给代码块或者方法加锁，同意时间只能执行一段代码。同步代码块如下，注意：锁对象可以是任意对象

Thread thread2 = new Thread(){
    @Override
    public void run() {
        synchronized (obj){
            System.out.println("I am thread.");
            System.out.println("I am thread..");
            System.out.println("I am thread...");
        }
        
        Thread.yield();
    }
};

同步方法：

1）非静态同步方法，锁对象是this（当前对象）

public synchronized void run() {
    for(int i = 10; i < 1000; i++){
        System.out.println("thread 1 is running");
    }
}

2）静态的同步方法，锁对象是该类的字节码对象

public static synchronized void run() {
    for(int i = 10; i < 1000; i++){
        System.out.println("thread 1 is running");
    }
}

死锁：有如下两个线程，当同时获得筷子左和筷子右才能吃饭，第一个线程获得了筷子左，去拿筷子右的时候，发现筷子右被锁住了。因此第一个线程处于block状态。第二个线程拥有了筷子右，去拿筷子左的时候发现筷子左被第一个线程锁住了，拿不到，自己也将筷子右锁住了。因此第一个线程一直在等待筷子右，第二个线程一直在等待筷子左。造成了死锁。

private static String s1 = "筷子左";
private static String s2 = "筷子右";
public static void main(String[] args) {
   //死锁
    new Thread(){
        @Override
        public void run() {
            synchronized(s1){
                System.out.println("我拿到了筷子左，等待筷子右");
                synchronized(s2){
                    System.out.println("我拿到了筷子左和筷子右，可以吃饭了"); 
                }
            }
        }
    }.start();
    new Thread(){
        @Override
        public void run() {
            synchronized(s2){
                System.out.println("我拿到了筷子右，等待筷子左");
                synchronized(s1){
                    System.out.println("我拿到了筷子右和筷子左，可以吃饭了");
                }
            }
        }
    }.start();
}

线程安全的容器：hashTable,vector,StringBuffer,Collection.synchonized(xxx)