JAVA多线程基础

一：线程与进程

1 线程：进程中负责程序执行的执行单元
线程本身依靠程序进行运行
线程是程序中的顺序控制流，只能使用分配给程序的资源和环境

2 进程：执行中的程序
一个进程至少包含一个线程

3 单线程：程序中只存在一个线程，实际上主方法就是一个主线程

4 多线程：在一个程序中运行多个任务
目的是更好地使用CPU资源

二：线程的实现

1：继承Thread类

　　

package Threads;

public class Thread_one extends Thread{
    
    @Override
    public void run() {
        // TODO Auto-generated method stub
        System.out.println(Thread.currentThread().getName());
    }
}

我们继承Thread类，然后重写run（）方法，写入你要执行的操作；

线程了类是创建好了，下面就是使用这个线程类：

package Threads;

public class Test1 {
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread_one().start();
        }
    }
}

正确的启动线程的方法是start（）方法，而不是使用run（）方法，下面具体说明 ；

运行的结果：

　　

我们可以发现多次运行结果是不一样的：

下面我们把启动改为run（）试一试；

package Threads;

public class Test1 {
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread_one().run();
        }
    }
}

 多次运行发现结果都是一样的，发现运行的都是main这个主线程，而没有创建新的线程：

　　总结 run（）和start（）的区别：

　　①：首次正确启动一个线程是使用start（）方法；

　　②：run（）方法中只是定义需要执行的任务，如果调用run方法，即相当于在主线程中执行run方法，跟普通的方法调用没有任何区别，此时并不会创建一个新的线程来执行定义的任务。

　　③：start（）在调用start（）方法后，线程就进入了就绪的状态，其实也就是一个可运行的状态，什么时候运行是根据cpu的调度的，看这个线程是否抢到了cpu的资源，所以说我们执行多个线程多次执行的顺序结果是不一样的；

 2:实现Runnable

package Threads;

public class Thread_two implements Runnable{

    @Override
    public void run() {
        // TODO Auto-generated method stub
        System.out.println(Thread.currentThread().getName());
    }

}

继承Thread和实现Runnable实现一个线程过程都差不多；

调用启动有些区别：

package Threads;

public class Test2 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        for (int i = 0; i < 10; i++) {
            new Thread(new Thread_two()).start();
        }
    }
}

我们查看Thread源码发现，他需要一个Runnable类型的对象；

 

我们附给他我们实现Runnable接口的对象

运行发现实现了效果：

总结：

实现Runnable接口比继承Thread类所具有的优势：

1）：可以避免java中的单继承的限制

 四：线程的不同状态及转换：

 

1、新建状态（New）：新创建了一个线程对象。

2、就绪状态（Runnable）：线程对象创建后，其他线程调用了该对象的start()方法。该状态的线程位于可运行线程池中，变得可运行，等待获取CPU的使用权。

3、运行状态（Running）：就绪状态的线程获取了CPU，执行程序代码。

4、阻塞状态（Blocked）：阻塞状态是线程因为某种原因放弃CPU使用权，暂时停止运行。直到线程进入就绪状态，才有机会转到运行状态。阻塞的情况分三种：

（一）、等待阻塞：运行的线程执行wait()方法，JVM会把该线程放入等待池中。

（二）、同步阻塞：运行的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM会把该线程放入锁池中。

（三）、其他阻塞：运行的线程执行sleep()或join()方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。

5、死亡状态（Dead）：线程执行完了或者因异常退出了run()方法，该线程结束生命周期。

解析：

新建状态：

 

只是创建了这个线程对象。

 就绪状态：

该状态的线程位于可运行线程池中，变得可运行，等争抢到cpu资源后就才会真正的进入到可运行的状态；

 运行状态：就绪状态的线程获取了CPU，执行程序代码。

 阻塞状态：

 ①：wait();

 

只能用 notify唤醒 或者notifyall

②：sleep

定义毫秒数，到时间自动唤醒，继续执行任务；

 ③：yield

 线程的礼让，让正在执行的线程变成可运行状态，然后在重新争抢cpu。

yield()应该做的是让当前运行线程回到可运行状态，以允许具有相同优先级的其他线程获得运行机会。因此，使用yield()的目的是让相同优先级的线程之间能适当的轮转执行。但是，实际中无法保证yield()达到让步目的，因为让步的线程还有可能被线程调度程序再次选中。

 ④：join加入主线程；

让正在运行的主线程停止，然后先运行这个线程。

package Threads;

public class Test3 {
    public static void main(String[] args) {
            System.out.println("开始：");
            Thread3 t2=new Thread3();
            Thread t=new Thread(t2);
            t.start();
            System.out.println("结束：");
    }
}

 

这明显不是我们想要的结果：

 使用join加入主线程：

package Threads;

public class Test3 {
    public static void main(String[] args) throws InterruptedException {
            System.out.println("开始：");
            Thread3 t2=new Thread3();
            Thread t=new Thread(t2);
            t.start();
            t.join();
            System.out.println("结束：");
    }
}

 在很多情况下，主线程生成并起动了子线程，如果子线程里要进行大量的耗时的运算，主线程往往将于子线程之前结束，但是如果主线程处理完其他的事务后，需要用到子线程的处理结果，也就是主线程需要等待子线程执行完成之后再结束，这个时候就要用到join()方法了。

 

总结：

sleep和wait的区别：

1. 所属的层面不同：Thread类的方法：sleep() Object的方法：wait()。

2.wait停止的线程则需要使用notifyall（）和notifi（）唤醒；
3. 每个对象都有一个锁来控制同步访问。Synchronized关键字可以和对象的锁交互，来实现线程的同步。 sleep方法没有释放锁，而wait方法释放了锁，使得其他线程可以使用同步控制块或者方法。
4. wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，而sleep可以在任何地方使用 ；
5. sleep必须捕获异常，而wait，notify和notifyAll不需要捕获异常

五：线程常用的方法：

　　sleep(): 强迫一个线程睡眠Ｎ毫秒。 
　　isAlive(): 判断一个线程是否存活。 
　　join(): 等待线程终止。 
　　activeCount(): 程序中活跃的线程数。 
　　enumerate(): 枚举程序中的线程。 
　　currentThread(): 得到当前线程。 
　　isDaemon(): 一个线程是否为守护线程。 
　　setDaemon(): 设置一个线程为守护线程。(用户线程和守护线程的区别在于，是否等待主线程依赖于主线程结束而结束) 
　　setName(): 为线程设置一个名称。 
　　wait(): 强迫一个线程等待。 
　　notify(): 通知一个线程继续运行。 
　　setPriority(): 设置一个线程的优先级。

六：线程的同步：

常用的同步方法就是使用synchronized关键字

为什么要使用线程同步，因为当一个资源可能会有多个线程访问的时候，当第一个线程进来之后对资源进行了修改，但是在修改的过程中第二个线程也进来了，那第二个线程取到的数据就不是最新的数据，是个虚假的数据，那么这个线程所执行的操作都没有意义了；

看个小例子：

package Threads;

public class Thread3 implements Runnable{
    private static int a=10;
    @Override
    public void run() {
        // TODO Auto-generated method stub
        try {
            Tong();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    public static  void Tong() throws InterruptedException{
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+"||||"+(--a));
            Thread.sleep(1000);
    }
    }
}




package Threads;

public class Test3 {
    public static void main(String[] args) throws InterruptedException {
            System.out.println("开始：");
            Thread3 t2=new Thread3();
            Thread t=new Thread(t2);
            Thread t3=new Thread(t2);
            t.start();
            t3.start();
            t.join();
            t3.join();
            System.out.println("结束：");
    }
}

里面的sleep就是模拟让两个线程同时访问一个资源

运行结果为：

我们可以看到是有重复数据的，也就是虚假的数据   thread-0和thread-1同时访问了count：7这个数据；

解决办法就是使用同步方法：

package Threads;

public class Thread3 implements Runnable{
    private static int a=10;
    @Override
    public void run() {
        // TODO Auto-generated method stub
        try {
            Tong();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    public static synchronized void Tong() throws InterruptedException{
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+"||||"+(--a));
            Thread.sleep(1000);
    }
    }
}

加上synchronized 关键字

总结：其实同步就是对这个资源对象就行加锁，只能同时有一个线程能操作这个资源，如果有第二个线程要访问，那只有等第一个线程执行结束之后才能进行访问；

 七：实现经典多线程例子生产者，消费者：

首先创建商品类

package Threads;

public class Piao {
    private int count=5;
    
    public synchronized void sheng() throws InterruptedException{
        if(count>=10){
            System.out.println("商品过多："+count);
            wait();
        }else{
            System.out.println("商品生产成功："+(++count));
            notify();
        }
    }
    public synchronized void mai() throws InterruptedException{
        if(count<=0){
            System.out.println("商品库存不够："+count);
            wait();
        }else{
            System.out.println("商品卖出成功："+(--count));
            notify();
        }
    }
}

 在创建生产者和消费者：

package Threads;

public class Sheng implements Runnable{
    private Piao p;
    
    public Sheng(Piao p) {
        super();
        this.p = p;
    }
    @Override
    public void run() {
        // TODO Auto-generated method stub
        for (int i = 0; i < 10; i++) {
            try {
                p.sheng();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
}




package Threads;

public class Mai implements Runnable{
    private Piao p;
    
    public Mai(Piao p) {
        super();
        this.p = p;
    }
    @Override
    public void run() {
        // TODO Auto-generated method stub
        for (int i = 0; i < 10; i++) {
            try {
                p.mai();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
}

 测试类：

package Threads;

public class Test4 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Piao p=new Piao();
        new Thread(new Mai(p)).start();
        new Thread(new Sheng(p)).start();
    }

}

 运行结果为：