Java笔记-多线程

多线程：

• 进程是一个应用程序。
• 线程是一个进程中的执行场景/执行单元
• 一个进程可以启动多个线程。

例如：在DOS命令窗口输入一个java hello，会启动JVM，JVM再启动一个主线程调用main方法，
同时再启动一个垃圾回收器来看护，java程序至少有两个线程并发，一个是垃圾回收线程，一个是执行main方法的主线程。

• 进程A和进程B的内存独立不共享。
• 线程A和线程B的方法区和堆内存共享，但内存独立，一个线程一个栈，栈与栈之间互不干扰。
• 多线程并发可以提高效率，java中的多线程机制是为了提高程序的处理效率。
• main方法结束只是主线程结束了，主栈空了，其他栈（线程）可能还没结束。
• 单核CPU不能做到真正的多线程并发，但是能做到给人一种多线程并发的感觉。

在java中实现多线程：

1.编写一个类，直接继承java.lang.Thread,重写run方法，run方法中的程序运行在分支线程中。
在主线程中new这个类，调用这个类的start（）方法，启动分支线程，分支线程会自动执行run（）方法。
例如：

public class Threadtest01 {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start();
        for (int i = 0; i < 1000; i++) {
            System.out.println("主线程："+i);
        }
    }
}


class MyThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i <1000 ; i++) {
            System.out.println("支线程"+i);
        }
    }
}

说明：start（）方法的作用是，启动一个分支线程，在JVM中开辟一个新的栈空间，这段代码执行完之后，就开辟了一个新的栈空间，start（）方法结束，线程启动成功，自动调用run（）方法。并且run（）方法在分支栈的底部。main方法在主栈的栈底部，run方法在分支栈的栈底部，run和main是平级的。

2.（常用）编写一个类实现java.lang.Runnable接口，创建Thread线程对象，使用start方法启动线程。

public static void main(String[] args) {
        Thread t = new Thread(new MyRunnable());
        t.start();
        for (int i = 0; i < 1000; i++) {
            System.out.println("主线程："+i);
        }
    }
    private static class MyRunnable implements Runnable{
        @Override
        public void run() {
            for (int i = 0; i <1000 ; i++) {
                System.out.println("支线程"+i);
            }
        }
    }

也可以采用匿名内部类的形式创建对象。

3.实现Callable接口，这种实现线程的方式可以获取线程的返回值。
java.until.concurrent（JUC包，属于java并发包）
步骤：创建“未来任务”对象，参数需要给一个Callable接口实现类对象。创建线程对象，启动线程。

public static void main(String[] args) throws ExecutionException, InterruptedException {
        FutureTask task = new FutureTask(new Callable() {
            @Override
            public Object call() throws Exception {
                return 300+100;//自动装箱
            }
        });
                Thread t=new Thread(task);
        t.start();
        Object obj = task.get();//这里main方法需要等待get方法执行结束，故可能会发生线程阻塞。
        System.out.println(obj);
    }

call方法类似于run方法，call方法有返回值。
优点：可以获得线程的执行结果。
缺点：效率比较低，在获取线程结果的时候会发生阻塞。

线程中的各种状态：

刚new出来的线程对象：新建状态
调用start方法，进入就绪状态，又叫可运行状态，表示当前线程具有抢夺CPU时间片的权利。
当一个线程抢夺到CPU时间片之后，进入运行状态，执行run方法，执行run方法标志线程进入运行状态。
当占用CPU时间片用完之后，会回到就绪状态继续抢夺CPU时间片，当再次抢到CPU时间片之后，会重新进入run方法接着上一次代码继续执行。
run方法执行结束，进入死亡状态。
阻塞状态：当线程在运行状态遇到阻塞事件（如输入、sleep）等，线程进入阻塞状态，阻塞状态的线程会放弃之前占有的时间片。
阻塞解除后，会进入到就绪状态。

线程中常见方法：

线程对象.getName();	//获得线程对象的名字
线程对象.setName(“名字”);	//修改线程对象的名字
static Thread currentThread()	//这个方法是返回当前线程对象
static void sleep(long millis)	//让当前进程进入休眠状态，进入阻塞状态，放弃占有的时间片。
void interrupt()	//中断这个进程，可以使正在睡眠的进程出异常，进而结束睡眠。

注意：run（）方法在父类中没有抛出任何异常，子类不能比父类抛出更多的异常，故run（）方法不能throws异常，只能try-catch。常用的终止线程的方法是：在类中添加布尔标记，用if语句来控制线程的执行，通过修改布尔标记来终止程序。

常见的线程调度模型：

抢占式调度模型：哪个线程的优先级高，抢到的CPU时间片的概率就高一些。java采用抢占式调度模型。
均分式：调度模型:平均分配CPU时间片，每个线程占有的CPU时间片时间长度一样，平均分配，一切平等。

void setPriority(int newPriority)	//设置线程的优先级。
int getPriority()	//获取线程的优先级。

最低优先级：1; 默认优先级：5; 最高优先级：10.

static void yield()	//让位方法，暂停当前执行的线程对象，并执行其他线程。会使得当前线程从“运行状态”回到“就绪状态”
void join()	//合并线程，等待这个进程死亡

public class Threadtest03 {
    class thread1 extends Thread{
        public void dosome() throws InterruptedException {
            thread2 t = new thread2();
            t.join();
        }
    }
}
class thread2 extends Thread{
}

例如：thread1线程会进入阻塞，t线程执行，直到t线程结束，当前线程才继续，在哪个进程用这个方法，哪个进程就阻塞。

线程安全：

什么时候数据在多线程并发的环境下会存在安全问题？
1.多线程并发。
2.有数据共享
3.共享数据有修改行为。
解决方法：线程排队执行（不能并发）
这种机制被称为：线程同步机制。

异步编程模型：
线程t1和t2，各自执行各自的，t1不管t2，t2不管t1。多线程并发，效率较高。异步就是并发
同步编程模型：
线程t1和t2，两个线程发生等待关系，t1在执行时，t2必须等待t1执行完毕，才能执行。效率较低，线程排队执行。同步就是排队。

线程同步机制语法：
synchronize（）{
//线程同步代码块
}
（）中的数据必须是多线程共享的对象，才能达到多线程排队。
说明：在java中，每个对象都有一把锁，就是标记，若有两个线程去执行synchronize的代码，先到的线程会占住这个对象的锁，另一个线程到时，必须等待先来的线程执行完，归还锁之后，后来的对象才能再占用这个锁去执行代码。

在运行状态下遇到synchronize就会放弃原先占有的CPU时间片，进入锁池（lockpool）寻找共享对象的对象锁，直到找到了才会回到就绪状态。

synchronize（）在（）中放一个字符串时，就会使得所有线程同步。
注意：局部变量永远都不会存在线程安全的问题，因为局部变量不共享。
而静态变量、实例变量分别在方法区、堆中，数据时共享的，有可能出现线程安全问题。
sychronize出现在实例方法上时，一定锁的是this，不能是其他对象，所以不灵活。
表示整个方法都需要同步，可能会无故地扩大同步范围，导致效率变低，所以这种方式不常用。
优点：代码可以写得少，节俭了。

线程安全的类：
StringBuffer是线程安全的
Stringbuilder是非线程安全的
Arraylist是非线程安全的
Vector是线程安全的
HashMap、HashSet是非线程安全的
Hashtable是线程安全的

sychronize的两种写法：
1.同步代码块：
sychronize（线程共享对象）{
同步代码快；
}
灵活
2.在实例方法上使用sychronize表示共享对象一定是this，并且同步代码块是整个方法体。
3.在静态方法上使用synchronize表示找类锁，类锁永远只有一把。保证静态变量的安全。

死锁：

死锁的写法（背）：

public static void main(String[] args) {
        Object o1 = new Object();
        Object o2 = new Object();
  Thread m1 = new MyThread1(o1,o2);
  Thread m2 = new MyThread2(o1,o2);
  m1.start();
  m2.start();
    }
}

class MyThread1 extends Thread{
    Object o1;
    Object o2;
 MyThread1(Object o1,Object o2){
     this.o1=o1;
     this.o2=o2;
 }
 public void run(){
synchronized (o1){
    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    synchronized (o2){

    }
}
    }
}
class MyThread2 extends Thread{
    Object o1;
    Object o2;
    MyThread2(Object o1,Object o2){
        this.o1=o1;
        this.o2=o2;
    }
    public void run(){
synchronized (o2){
    synchronized (o1){

    }
  }
 }

由于在MyThread1中先锁o1再锁o2，MyThread2先锁o2，再锁o1，当o1被MyThread1锁住，o2被MyThread2锁住，就形成了死锁。
在开发中最好避免嵌套使用synchronize。

开发中如何避免线程安全问题：

1.尽量用局部变量代替“实例变量和静态变量”
2.如果是实例变量，可以考虑创建多个对象，这样实例变量的内存就不共享了。（一个线程对应一个对象）
3.如果不能使用局部变量，对象也无法创建多个，这时候只能选择synchronize，线程同步机制。

守护线程：

后台线程，如垃圾回收线程。
一般守护线程是个死循环，所有的用户线程只要一结束，守护线程自动结束。
注意：主线程main方法是一个用户线程。
void setDaemon(boolean on) //可以将一个用户线程设置成守护线程

定时器：

间隔特定的时间，执行特定的程序。
在实际的开发中，每隔一定的时间需要执行一定的程序。
1.设置睡眠时间，这是最原始的方式。
2.使用java.util.Timer,很少用，因为很多定时框架支持定时任务。
3.目前使用较多的是Spring框架中提供的SpringTask框架，只要完成简单的配置，就能完成定时器的任务。

Timer：

使用定时器指定定时任务
void schedule(TimerTask task, Date firstTime, long period) //task为要执行的任务，firstTime是第一次执行的时间，period是执行的间隔。

Object类中wait和notify方法：

每个java对象都有。
wait（）方法的作用：
Object o = new Object();
o.wait();
让正在o对象上活动的线程进入等待状态，释放之前占有的o对象的锁，无期限等待，直到被唤醒为止。

notify（）方法的作用：
Object o = new Object();
o.notify();
唤醒o对象上等待的线程。
notifyAll（）方法：唤醒o对象上处于等待的所有线程，唤醒时，并没有丢掉原来的锁。