第十章 线程

线程

一、程序,进程,线程

程序:是为了完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码。

进程：就是正在执行的程序，从Windows角度讲，进程是操作系统进行资源分配的最小单位。

线程：进程可进一步细化为线程，是一个进程内部的最小执行单元，是操作系统进行任务调度的最小单元，隶属于进程。

二、进程和线程的关系

一个进程可以包含多个线程，一个线程只能属于一个进程，线程不能脱离进程而独立运行

每一个进程至少包含一个线程，在主线程中开始执行程序。Java程序的入口main()方法就是在主线程中被执行的

在主线程中可以创建并启动其他的线程

三、创建线程

//创建线程,在线程中写独立执行的代码
public class MythreadDemo extends Thread {//继承Thread类,线程代码存放Thread子类run方法中
//run方法写执行代码
    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println("mythreag:"+i);
        }
    }
}
public class Test {
    public static void main(String[] args) {
        //在主线程中创建并启动
        MythreadDemo mythreadDemo=new MythreadDemo();
        mythreadDemo.start();//启动线程调用start方法,不能调用run(),不然就是普通方法调用
        for (int i = 0; i < 1000; i++) {
            System.out.println("main:"+i);
        }
    }
}

public class ThreadDemo implements Runnable{实现Runnable接口,线程代码存在接口的子类的run方法，避免单继承的局限性
    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println("thread:"+i);
        }
    }
}
public class Test {
    public static void main(String[] args) {
        ThreadDemo threadDemo=new ThreadDemo();
        Thread thread=new Thread(threadDemo);
        thread.start();
        for (int i = 0; i < 1000; i++) {
            System.out.println("main:"+i);
        }
    }
}

四、Thread类中的方法

public class ThreadDemo implements Runnable{//避免单继承的局限性
    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            Thread.sleep(1000")
            System.out.println(Thread.currentThread().getName()+i);// currentThread()获得当前线程,getname获得线程的名字
        }
    }
}
public class Tast {
    public static void main(String[] args) {
        ThreadDemo threadDemo=new ThreadDemo();
        Thread thread1=new Thread(threadDemo,"aa:");
        Thread thread2=new Thread(threadDemo,"bb:");//创建线程,添加任务,并命名
        thread1.start();//启动线程
        thread2.start();
        thread1.setPriority(10);//设置线程优先级,高优先级的线程有更多机会获得执行权,但不是低优先级的线程没有机会
        thread2.setPriority(1);
        for (int i = 0; i < 1000; i++) {
            System.out.println(i);
        }
        System.out.println("-----------------------"+thread1.getPriority());
        System.out.println("------------------------"+thread2.getPriority());
    }

}

五、线程优先级

● 事实上，计算机只有一个CPU，各个线程轮流获得CPU的使用权，才能
执行任务；
● 优先级较高的线程有更多获得CPU的机会，反之亦然；
● 优先级用整数表示，取值范围是1~10，一般情况下，线程的默认优先级
都是5，但是也可以通过setPriority和getPriority方法来设置或返回优
先级；

调度策略
● 时间片
● 抢占式：高优先级的线程抢占CPU
●Java的调度方法
● 同优先级线程组成先进先出队列，使用时间片策略
● 对高优先级，使用优先调度的抢占式策

public class Tast {
    public static void main(String[] args) {
        ThreadDemo threadDemo=new ThreadDemo();
        Thread thread1=new Thread(threadDemo,"aa:");
        Thread thread2=new Thread(threadDemo,"bb:");//创建线程,添加任务,并命名
        thread1.start();
        thread2.start();
        thread1.setPriority(10);//设置线程优先级,高优先级的线程有更多机会获得执行权,但不是低优先级的线程没有机会
        thread2.setPriority(1);
    }

}
public class ThreadDemo implements Runnable{//避免单继承的局限性
    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            Thread.yield();//线程让步
            System.out.println(Thread.currentThread().getName()+i);//获得线程的名字
        }
    }
}

六、线程状态

• 新建：当一个Thread类或其子类的对象被声明并创建时，新生的线程对
  象处于新建状态
  ● 就绪：处于新建状态的线程被start（）后，将进入线程队列等待CPU时
  间片，此时它已具备了运行的条件，只是没分配到CPU资源
  ● 运行：当就绪的线程被调度并获得CPU资源时，便进入运行状态，run
  （）方法定义了线程的操作和功能
  ● 阻塞：在某种特殊情况下，被人为挂起或执行输入输出操作时，让出CPU并临时中止自己的执行，进入阻塞状态
  ● 死亡：线程完成了它的全部工作或线程被提前强制性地中止或出现异常
  导致结束

七、线程的分类

Java中的线程分为两类：用户线程和守护线

任何一个守护线程都是费守护线程的保姆

当非守护线程没有结束工作时，守护线程都在工作

当是最后一个非守护线程结束工作时，守护线程随着JVM一起结束工作

在设置线程为守护线程时必须在线程启动前设置

public class ThreadDemo2 extends Thread{
    Socket socket;
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName()+i);
        }
    }
}
public class ThreadDemo1 extends Thread{
    @Override
    public void run() {//守护线程一直工作
        while (true) {
            System.out.println("守护线程");
        }
    }
}
public class Task {
    public static void main(String[] args) {
        ThreadDemo1 threadDemo1=new ThreadDemo1();
        ThreadDemo2 threadDemo2=new ThreadDemo2();
        threadDemo2.start();
        threadDemo1.setDaemon(true);//设置线程为守护线程
        threadDemo1.start();
    }
}

八、多线程

何时需要多线程

• 程序需要同时执行两个或多个任务时
• 程序需要实现一些需要等待的任务时，如用户输入文件读写操作、网络操作、搜素等
• 需要一些后台运行的程序时

多线程的优点

• 提高程序的响应
• 提高CPU的利用率
• 改善程序的结构，将复杂任务分为对多个线程，独立运行

多线程的缺点

线程也是程序，所以线程需要占用内存，线程越多占用内存也越多

多线程之间对共享资源的访问会相互影响，必须解决竞用共享资源的问题

//卖票
public class ThreadDemo implements Runnable {
    static int num = 10;//票数

    @Override
    public void run() {

        while (true) {
            if (num > 0) {
                System.out.println(Thread.currentThread().getName() + "票数:" + num);
                num--;
            }
        }
    }
}
public class Task {
    public static void main(String[] args) {
        ThreadDemo threadDemo=new ThreadDemo();
       Thread t1=new Thread(threadDemo,"窗口一");
        Thread t2=new Thread(threadDemo,"窗口二");
        t1.start();
        t2.start();
    }


}

九、线程同步

​ 并发与并行

• 并行：多个CPU同时执行多个任务。比如：多个人做不同的事情

• 并发：一个CPU（采用时间片）同时执行多个任务

  多线程同步
  ● 多个线程同时读写同一份共享资源时，可能会引起冲突。所以引入线程“同步”机制，
  即各线程间要有先来后到；
  同步就是排队+锁：
  ● 几个线程之间要排队，一个个对共享资源进行操作，而不是同时进行操作
  ● 为了保证数据在方法中被访问时的正确性，在访问时加入锁机制

  确保一个时间点只有一个线程访问共享资源。可以给共享资源加一把锁，哪个线程获取了这把锁，才有权利访问该共享资源

  synchronized(同步监视器)

   public void run() {
          while (true) {
              if (num>0){
              
              }else {
                  break;
              }
  //使用synchronized(同步监视器)关键字代码块
    /*synchronized (object){//要求对象只有一个
              if (num > 0) {
                  System.out.println(Thread.currentThread().getName() + "票数:" + num);
                  num--;
              }
            }//同步代码块执行完成后同步对象(锁)会自动释放*/
          }
  
  
          }
  //使用synchronized(同步监视器)关键字同步方法
      public static synchronized void IOd () {//synchronized在修饰方法时同步对象默认是this,一旦创建多个线程对象,就会调多个方法
          if (num > 0) {
              System.out.println(Thread.currentThread().getName() + "票数:" + num);
              num--;
          }
      }
  }
  

同步监视器
同步监视器可以是任何对象,必须唯一,保证多个线程获得是同一个对象
(锁). 同步监视器的执行过程
1.第一个线程访问，锁定同步监视器，执行其中代码.

2.第二个线程访问，发现同步监视器被锁定，无法访问.

3.第一个线程访问完毕，解锁同步监视器.

4.第二个线程访问，发现同步监视器没有锁，然后锁定并访问

Lock(锁)

public class LockDemo implements Runnable {
     int num = 10;
     Lock lock=new ReentrantLock();//创建一个锁对象，Lock是一个接口，ReentrantLock是实现类
    @Override
    public void run() {

        while (true) {
            if(num>0){
            sub();
            }else {
                break;
            }
            }
        }
       public  void sub () {
        lock.lock();//加锁   lock只能锁代码块
        if (num > 0) {
            try {
                Thread.sleep(1000);
                System.out.println(Thread.currentThread().getName() + "票数:" + num);
                num--;
            } catch (InterruptedException e) {
                e.printStackTrace();
            }finally {
                lock.unlock();//开锁
            }

        }
    }

        }
public class Task {
    public static void main(String[] args) {
        LockDemo threadDemo=new LockDemo();
       Thread t1=new Thread(threadDemo,"窗口一");
        Thread t2=new Thread(threadDemo,"窗口二");
        t1.start();
        t2.start();
    }


}

十、线程死锁

死锁
不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃
自己需要的同步 资源，就形成了线程的死锁. 出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续

public class ThreadDemo extends Thread {
    boolean b;

    public ThreadDemo(boolean b) {
        this.b = b;
    }

   static Object objA=new Object();
    static Object objB=new Object();

    @Override
    public void run() {
        if(b) {
            synchronized (objA) {//要求对象只有一个

                System.out.println("objA");

                synchronized (objB) {//要求对象只有一个

                    System.out.println("objB");
                }
            }
        }else {
            synchronized (objB){//要求对象只有一个

                System.out.println("onjB" );

                synchronized (objA){//要求对象只有一个

                    System.out.println("onjA" );
                }
            }
        }

        }

}
public class Task {
    public static void main(String[] args) {
        ThreadDemo t1=new ThreadDemo(true);
        ThreadDemo t2=new ThreadDemo(false);
        t1.start();
        t2.start();
    }


}

十一、线程通信

线程通讯是指多个线程通过消息传递实现相互牵制相互作用

涉及三个方法：

• wait一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器。
• notify一旦执行此方法，就会唤醒被wait的一个线程。如果有多个线程被wait，就唤醒优先级高的那个。
• notifyAll一旦执行此方法，就会唤醒所有被wait的线程。

//生产者/消费者问题
public class Counter {
    int num=0;
    public synchronized void add(){//生产
        while (true) {
            if (num == 0) {
                this.notify();//唤醒线程
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                num++;
                System.out.println("生产者生产了一个商品");
            }
            try {
                this.wait();//线程等待
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    public synchronized void sub() {//消费
        while (true) {
            if (num > 0) {
                this.notify();
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                num--;
                System.out.println("消费者消费了一个商品");
            }
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
public class CustomerThread extends Thread{//消费者
    Counter counter;

    public CustomerThread(Counter counter) {
        this.counter = counter;
    }
    @Override
    public void run() {
        counter.sub();
    }
}
public class ProductorThread extends Thread{//生产者
    Counter counter;

    public ProductorThread(Counter counter) {
        this.counter = counter;
    }//构造方法传值

    @Override
    public void run() {
        counter.add();
    }
}
public class Tast {
    public static void main(String[] args) {
        Counter counter=new Counter();
        ProductorThread pt=new ProductorThread(counter);
        CustomerThread ct=new CustomerThread(counter);
        pt.start();
        ct.start();
    }
}

十二、新增创建线程方式

实现Callable接口与使用Runnable相比，Callable功能更强大些. • 相比run（）方法，可以有返回值

• 方法可以抛出异常
• 支持泛型的返回值
• 需要借助FutureTask类，获取返回结果

public class Mythread implements Callable {//实现Callable接口
    int num;
    @Override
    public Object call() throws Exception {
        for (int i = 0; i < 10; i++) {
            System.out.println(i);
            num+=i;
        }
        return num;//返回值
    }
}
public class Test {
    public static void main(String[] args) {
        Mythread mythread=new Mythread();
        FutureTask<Integer> function=new FutureTask(mythread);//FutureTask类传参
        Thread t=new Thread(function);
        t.start();
        try {
            Integer m= function.get();//借助FutureTask获取返回结果
            System.out.println(m);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }


    }
}