JAVA第十章---线程

程序：为实现某种功能，使用计算机语言编写的一系列指令的集合，

指的是静态代码（安装在电脑上的文件）

进程：也是称为进程，是运行中的程序

进程是操作系统进行资源分配的最小单元

线程：进程可以进一步细化为线程，就是进程中最小的执行单元（任务）

是cpu进行调度的最小单元

进程与线程的关系

一个进程可以包含多个线程（一个QQ可以有多个窗口）

一个线程只能隶属于一个进程（QQ聊天窗口只能属于QQ）

一个进程中至少包含一个线程

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

一个进程的线程共享该进程的内存资源

java中线程创建方式

方式1:继承Thread

/*
java中创建线程方式1
写一个类继承java.lang.Thread
重写run()
 */
public class MyTheard extends Thread{
    @Override
    public void run() {
        for(int i=0;i<1000;i++){
            System.out.println("Mythrea"+i);
        }
    }
}

public class threatest {
    public static void main(String[] args) {
        MyTheard myTheard=new MyTheard();
        //myTheard.run();
        myTheard.start();

        for(int i=0;i<1000;i++){
            System.out.println("main"+i);
        }
    }
}

 

方式2:实现Runnable接口 new Thread类对象

/*
  java 中创建线程方式2：
  只先创建线程要执行的任务，创建一个类，实现Runnable接口
  重写任务执行run().
  实现Runnable接口创建的优点：
  1.因为java是单继承，一旦继承一个类就不能在继承其他类，避免单继承的局限。
  2.适合多线程来处理同一份资源使用
 */
public class Task implements Runnable{
    @Override
    public void run() {
        for(int i=0;i<1000;i++){
            System.out.println("自定义："+i);
        }
    }
}

public class threatest {
    public static void main(String[] args) {
        Task task=new Task();
        Thread thread=new Thread(task);
        thread.start();

        for(int i=0;i<1000;i++){
            System.out.println("main:"+i);
        }
    }
}

 

Thread类中常用的方法

/*
  Thread类中的方法：
    run();  用来定义线程要执行的任务代码
    start(); 启动线程的
    currentThread();  获取到当前线程
    getTd();  获取线程id
    setName();  为线程设置名字
    getPriority();  获取线程的优先级
    setPriority();  设置优先级  优先级为1-10 默认是5  作用是为操作系统调度算法提供的
    getName();  获取线程名字
    join();   让后面的线程进入等待
    sleep();  使线程进入睡眠
    yield();   退出cpu，重新进行排队
 */
public class Mythread extends Thread implements Runnable{
    @Override
    public void run() {
      /*  System.out.println(Thread.currentThread());
        System.out.println(Thread.currentThread().getName());
        System.out.println(Thread.currentThread().getPriority());
        System.out.println(Thread.currentThread().getState());*/
        System.out.println(Thread.currentThread().getName()+":"+Thread.currentThread().getPriority());
    }
}

public class test {
    public static void main(String[] args) throws InterruptedException {
        Mythread mythread=new Mythread();
        mythread.getState();
        mythread.setName("窗口一");
        mythread.setPriority(10);
        mythread.start();
        //mythread.join();

        Mythread mythread1=new Mythread();
        mythread1.setName("窗口二");
        mythread1.start();
        mythread1.setPriority(1);
        System.out.println(Thread.currentThread().getName()+":"+Thread.currentThread().getPriority());
    }
}

 

操作系统调用算法: 操作系统常用调度算法，你知道几个？-操作系统原理调度算法

线程优先级

● 事实上，计算机只有一个CPU，各个线程轮流获得CPU的使用权，才能 执行任务；

● 优先级较高的线程有更多获得CPU的机会，反之亦然；

● 优先级用整数表示，取值范围是1~10，一般情况下，线程的默认优先级 都是5，但是也可以通过setPriority和getPriority方法来设置或返回优 先级；

线程生命周期(生老病死 创建--销毁)

线程状态:

 新建: 刚刚创建了一个线程对象,并没有启动
 
 就绪(可运行): 调用start()后,线程就进入到了就绪状态,进入到了操作系统的调度队列
 
 运行状态: 获得了cpu执行权,进入到cpu执行
 
 阻塞状态:  例如调用了sleep(), 有线程调用了join(),线程中进行Scanner输入....
 
 死亡/销毁:  run()方法中的任务执行完毕了.

多线程的概念

在一个程序中可以创建多个线程执行.

多线程优点:

提高程序执行效率 3个任务可以在不同的线程中同时执行 提高了cpu的利用率 改善程序结构, 例如将一个大的任务拆分成若干个小任务执行

多线程缺点:

线程多了,占用内存 cpu开销就变大了 (扩充内存,升级cpu)

   多个线程访问操作同一个共享的数据(例如 买票  抢购 秒杀.....)
   
如何解决多线程操作共享数据的问题:
​
    排队+锁      在关键的步骤处,多个线程只能一个一个的执行.

Lock（锁）

• 从JDK 5.0开始，Java提供了更强大的线程同步机制-通过显式定义同步锁对象 来实现同步。同步锁使用Lock对象充当。

• java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的 工具。

• ReentrantLock类实现了Lock，它拥有与synchronized相同的并发性和内存 语义，在实现线程安全的控制中，可以显式加锁释放锁.

/*
   synchronized(同步锁对象){
       同步代码块
   }

   同步锁对象作用：用来记录有没有线程进入到同步代码块中，如果有线程进入到同步代码块，那么其他线程就不能进入
                直到上一个线程执行完同步代码块的内容，释放锁之后，其他线程才能进入
   同步锁对象要求：同步锁对象必须是唯一（多个线程拿到的是同一个对象）
 */
public class TicktThread extends Thread{

    static int num=10;
    static  Object obj=new Object();

    @Override
    public void run() {

        while (true){
           synchronized (obj){
               try {
                   sleep(500);
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
               if(num>0){
                   System.out.println(Thread.currentThread().getName()+"买到第"+num+"票");
                   num--;
               }
               else{
                   break;
               }
           }
        }
    }
}


public class Tickettest {
    public static void main(String[] args) {
        TicktThread tick1=new TicktThread();
        tick1.setName("窗口一");
        tick1.start();
        TicktThread tick2=new TicktThread();
        tick2.setName("窗口二");
        tick2.start();
        TicktThread tick3=new TicktThread();
        tick3.setName("窗口三");
        tick3.start();
        TicktThread tick4=new TicktThread();
        tick4.setName("窗口四");
        tick4.start();
        TicktThread tick5=new TicktThread();
        tick5.setName("窗口五");
        tick5.start();
    }
}

public class ticket extends Thread{
    static int num=10;
    /*
   synchronized修饰方法时，同步锁对象不需要我们指定
   同步锁对象会默认提供：
       1.非静态方法--锁对象默认时this
       2.静态方法--锁对象时当前类的class对象（类的对象，一个类的对象只有一个）
     */

    @Override
    public void run() {
        while (true){
            if(num<=1){
                break;
            }
            print();
        }
    }

    public static synchronized void print(){
        System.out.println(Thread.currentThread().getName()+"买到了第"+num+"张票");
        num--;
    }
}

线程通信

线程通讯指的是多个线程通过相互牵制，相互调度，即线程间的相互作用。

涉及三个方法：

.wait一旦执行此方法，当前线程就进入阻塞状态，并释放同步锁对象。

.notify一旦执行此方法，就会唤醒被wait的一个线程。如果有多个线程被wait， 就唤醒优先级高的那个。 .notifyAll一旦执行此方法，就会唤醒所有被wait的线程。

注意： .wait（），notify（），notifyAll（）三个方法必须使用在同步代码块或同步方 法中。

/*
sleep(long time)
属于Thread类中的方法
sleep休眠指定时间后，会自动唤醒
sleep()不会释放锁

wait（）
   属于Object类中的方法，必须要用锁对象调用
   wait后的线程，必须通过其他线程唤醒（notify notifyall）
   wait()会自动释放锁
 */
public class Counter {
    static int num = 1;

    public synchronized void add() throws InterruptedException {
        if (num == 0) {
            this.notify();
            num = 1;
            System.out.println("生产者线程生产了一件商品");
        } else {
            this.wait();
        }
    }

    public synchronized void sub() throws InterruptedException {
        if(num==1){
            this.notify();
            num=0;
            System.out.println("消费者线程购买了一件商品");
        }else{
            this.wait();
        }
    }
}