Java中的线程技术_java runnable 加sleep 会不执行-CSDN博客

本文链接：https://blog.csdn.net/xlqx11/article/details/49205345

一，进程、线程和多线程

进程：正在进行中的程序（直译）。
线程：进程中一个负责程序执行的控制单元（执行路径）。
多线程：一个进程中可以有多个执行路径，称之为多线程。
- 好处：解决了多部分代码同时运行的问题。
- 弊端：线程太多，会导致效率的降低。

二、创建进程方式

1. 方式一：继承Thread类

步骤：
1. 定义一个类继承Thread类。
2. 覆盖Thread类中的run方法。
3. 直接创建Thread的子类对象创建线程。
4. 调用start方法开启线程并调用线程的任务run方法执行。

构造方法：

Thread(Runnable target)分配新的 Thread 对象，target为其run 方法被调用的对象。

继承自Object的方法

void wait( ) / void wait(long timeout) 让线程处于冻结状态，被wait的线程会被存储到线程池中。
void notify( ) 唤醒线程池中的一个线程（任何一个都有可能）。
void notifyAll( ) 唤醒线程池中的所有线程。

注意：该三种方法只能由锁来调用

常用方法

static Thread currentThread( ) 返回对当前正在执行的线程对象的引用
long getId( ) 返回该线程的标识符。
void setName( String name )改变线程名称，使之与参数 name 相同。
String getName( ) 返回该线程的名称。
void setPriority( int newPriority ) 更改线程的优先级。
int getPriority( ) 返回线程的优先级。
Thread.State getState( ) 返回该线程的状态。

线程状态（6中）： NEW、RUNNABLE、BLOCKED、WAITING、TIMED_WAITING和TERMINATED已
String toString( ) 返回该线程的字符串表示形式，包括线程名称、优先级和线程组。
void run( ) 如果该线程是使用独立的 Runnable 运行对象构造的，则调用该 Runnable 对象的 run 方法；否则，该方法不执行任何操作并返回。
static void sleep( long millis ) 在指定的毫秒数内让当前正在执行的线程休眠（暂停执行）。
- wait和sleep区别
  1. wait可以指定时间也可以不指定。sleep必须指定时间
  2. 在同步中，对CPU的执行权和锁的处理不同
    - wait：释放执行权，释放锁
    - sleep：释放执行权，不释放锁
void start( ) 使该线程开始执行；Java 虚拟机调用该线程的 run 方法。
void join( ) 等待该线程终止（当A线程执行到B线程的.join()方法时，等B线程都执行完，A才会执行）。注：临时加入一个线程可以使用该方法。
static void yield( ) 暂停当前正在执行的线程对象，并执行其他线程。
void setDaemon( boolean on ) 将该线程标记为守护线程或用户线程。

2.方式二：实现 Runnable 接口（常用方式：避免了Java单继承的局限性）

步骤：
1. 定义类实现Runnable接口。
2. 覆盖接口中的run方法，将线程的任务代码封装到run方法中。
3. 通过Thread类创建线程对象，并将Runnable接口的子类对象作为Thread类的构造函数的参数进行传递（因为线程的任务都封装在Runnable接口子类对象的run方法中。所以要在线程对象创建时就必须明确要运行的任务）。
4. 调用线程对象的start方法开启线程。

三，线程安全问题

1. 产生原因：

多个线程在操作共享数据
操作共享数据的线程代码有多条

当一个线程在执行操作共享数据的多条代码过程中，其他线程参与了运算，就导致线程安全问题的产生。

2. 解决办法

对多条操作共享数据的语句，只能让一个线程都执行完。在执行过程中，其他线程不可以参与执行。

同步代码块

格式：

    synchronized(obj)
    {
        //obj是一个对象，表示锁(监视器锁)
        //持有锁的线程可以在同步中执行，没有持有锁的线程即使获取cpu的执行权，也进不去，因为没有获取锁。
    }

同步方法(函数)

格式：在方法上加上synchronized修饰符即可。（一般不直接在run方法上添加）
同步方法的同步监听器其实是 this

    synchronized 返回值类型 方法名（参数列表）
   ｛        

    ｝

同步函数和同步代码块的区别
- 同步函数的锁是固定的this
- 同步代码块的锁是任意的对象
  建议使用同步代码块
注意：
- 如果同步函数和同步代码块都使用this作为锁，就可以实现同步
- 静态同步函数的锁是该函数所属字节码文件对象，可以getClass方法获取，也可以用当前类名.class表示。
死锁：
常见情形为同步的嵌套，当两个线程相互等待对方释放同步监视器时就会发生死锁。一旦出现死锁，程序既不会发生任何异常，也不会出现任何提示。

同步锁

JDK 1.5以后的另一种同步机制，将同步和锁封装成对象

Lock接口（位于java.util.concurrent.locks包）：替代了同步代码块或者同步函数
- 子类：ReentrantLock
- 方法摘要：
  - Condition newCondition() 返回绑定到此 Lock 实例的新 Condition 实例,以调用其方法。
  - void lock( ) 获取锁
  - void unlock( ) 释放锁，为了防止异常出现，导致锁无法被关闭，所以锁的关闭动作要放在fianlly中
Condition接口（位于java.util.concurrent.locks包）：
- 替代了Object中的wait、notify和notifyAll方法，分别为：await、signal和signalAll方法。

四，线程间通信

1. 使用时机

多个线程在处理同一资源，但是任务却不同，这时就需要线程间通信。

2. 等待/唤醒机制方法

wait、notify和notifyAll都定义在Object类中，因为这些方法都是监视器（锁）的方法，锁可以是任意的对象，任意的对象调用方式一定在Object类中。

生产者消费者示例（生产一个，消费一个）：

    //该示例中，实现了本方只唤醒对方的操作    
    import java.util.concurrent.locks.*;

    class ProducerConsumerDemo {
        public static void main(String[] args) {
            Resource r=new Resource();

            //通过已有的锁获取两组监视器，一组监视生产者，一组监视消费者
            Producer pro=new Producer(r);
            Consumer con=new Consumer(r);

            Thread t1=new Thread(pro);
            Thread t2=new Thread(con);
            Thread t3=new Thread(pro);
            Thread t4=new Thread(con);

            t1.start();
            t2.start();
            t3.start();
            t4.start();
        }
    }


    class Resource {
        private String name;
        private int count=1;
        private boolean flag=false;

        private Lock lock=new ReentrantLock();

        private Condition condition_pro =lock.newCondition();
        private Condition condition_con =lock.newCondition();

        public void set(String name)throws InterruptedException {
            //加锁
            lock.lock();
            try {
                while(flag)
                    condition_pro.await();  //生产方线程被存储到线程池中

                this.name=name+"..."+count++;
                System.out.println(Thread.currentThread().getName()+".....生产者....."+this.name);
                flag=true;
                condition_con.signal();     //唤醒处于线程池中的消费方线程
            }
            // 使用finally块保证释放锁
            finally{
                lock.unlock();
            }

        }

        public void out()throws InterruptedException {
            //加锁
            lock.lock();
            try {
                while(!flag)
                    condition_con.await();  //消费方线程被存储到线程池中

                System.out.println(Thread.currentThread().getName()+"...消费者..."+this.name);
                flag=false;
                condition_pro.signal();     //唤醒处于线程池中的生产方线程
            }
            // 使用finally块保证释放锁
            finally {
                lock.unlock();
            }
        }
    }

    //定义生产者类，实现Runnable接口，覆盖run方法
    class Producer implements Runnable {
        private Resource res;
        Producer(Resource res) {
            this.res=res;
        }
        public void run(){
            while (true) {
                try {
                    res.set("+商品+");
                }
                catch (InterruptedException e) {
                }
            }
        }

    }

    //定义消费者类，实现Runnable接口，覆盖run方法
    class Consumer implements Runnable {
        private Resource res;
        Consumer(Resource res) {
            this.res=res;
        }

        public void run() {
            while (true) {
                try {
                    res.out();
                }
                catch (InterruptedException e) {
                }
            }
        }
    }