Java线程

---

 

程序,进程,线程

创建线程

Thread类中方法

线程状态

多线程的概念

线程同步

Lock

线程通信

新增创建线程方式

 

---

 

程序,进程,线程

程序：是为完成特定任务、用某种语言编写的一组指令的集合,即指一

段静态的代码.

进程：正在内存中运行的应用程序，如运行中的QQ，运行中的音乐播

放器,进程是操作系统进行资源分配的最小单位

线程：进程可进一步细化为线程，是一个进程内部的最小执行单元,是操

作系统进行任务调度的最小单元，隶属于进程

 

一个进程可以包含多个线程，

一个线程只能属于一个进程，线程不能脱离进程而独立运行；

每一个进程至少包含一个线程(称为主线程)；

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

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

创建线程

1.继承Thread类的方式

2.实现Runnable接口的方式

(1)继承Thread类的方式

在Java中要实现线程，最简单的方式就是扩展Thread类，重写其中的run方法，方法原型如下：

Thread类中的run方法本身并不执行任何操作，如果我们重写了run方法，当线程启动时，它将执行

run方法。

package newday8;

public class XianCheng extends Thread{
    @Override
    public void run() {
       for(int i=0;i<10000;i++){
           System.out.println("加油"+i);
       }
    }
}

实现Runnable接口的方式

java.lang.Runnable接口中仅仅只有一个抽象方法：

public void run()

也可以通过实现Runnable接口的方式来实现线程，只需要实现其中的run方法即

可；

Runnable接口的存在主要是为了解决Java中不允许多继承的问题

package newday8;

public class Mytask1 implements Runnable{

    @Override
    public void run() {
       /* for(int i=0;i<10000;i++){
            System.out.println("任务"+i);
        }*/
        //在任务中通过Thread.currentThread();可得知执行那个线程
        Thread thread=Thread.currentThread();
        System.out.println(thread.getName());


    }
}

实现Runnable接口方式的好处

【实现Runnable的好处】

1）避免了单继承的局限性

2）多个线程可以共享同一个接口实现类的对象，非常适合多个相同线程来处

理同一份资源

Thread类中方法常用方法：

 thread1.setPriority(6);//设置线程优先级
Thread.currentThread();可得知执行那个线程
 thread.start();启动
 thread.setDaemon(true);//设置线程为守护线程，必须在启动前设置
final void join() 等待线程终止
static Thread currentThread() 返回对当前正在执行的线程对象的引用
static void sleep(long millis) 让当前正在执行的线程休眠（暂停执行）休眠时间由milli s（毫秒）指定
final String getName() 返回线程的名称
final void setPriority(int newPriority) 设置线程的优先级
final int getPriority() 返回线程的优先级

线程优先级：

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

执行任务；

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

 优先级用整数表示，取值范围是1~10，一般情况下，线程的默认优先级

都是5，但是也可以通过setPriority和getPriority方法来设置或返回优

先级；

线程状态图解：

线程状态概念：

线程的状态：

新建：

当一个Thread类或其子类的对象被声明并创建时，新生的线程对

象处于新建状态

就绪：

处于新建状态的线程被start（）后，将进入线程队列等待CPU时

间片，此时它已具备了运行的条件，只是没分配到CPU资源

运行：

当就绪的线程被调度并获得CPU资源时，便进入运行状态，run

（）方法定义了线程的操作和功能

阻塞：

在某种特殊情况下，被人为挂起或执行输入输出操作时，让出

CPU并临时中止自己的执行，进入阻塞状态

死亡：

线程完成了它的全部工作或线程被提前强制性地中止或出现异常

导致结束

多线程的概念

 多线程是指程序中包含多个执行单元，即在一个程序中可以同时运行多

个不同的线程来执行不同的任务，也就是说允许单个程序创建多个并行

执行的线程来完成各自的任务。

何时需要多线程

程序需要同时执行两个或多个任务。

程序需要实现一些需要等待的任务时，如用户输入、文件读写操作、

网络操作、搜索等。

多线程的优点

提高程序的响应.

提高CPU的利用率.

 改善程序结构,将复杂任务分为多个线程,独立运行

多线程的缺点

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

多线程需要协调和管理，所以需要跟踪管理线程,使得cpu开销变大；

线程之间同时对共享资源的访问会相互影响,如果不加以控制会导致数据

出错.

package newday8;

public class Test {
    public static void main(String[] args) {
        for(int j=0;j<10000;j++){
            System.out.println("加         "+j);
        }
        XianCheng xianCheng=new XianCheng();
        xianCheng.start();
    }
}



package newday8;

public class XianCheng extends Thread{
    @Override
    public void run() {
       for(int i=0;i<10000;i++){
           System.out.println("加油"+i);
       }
    }
}

线程同步

多线程同步

多个线程同时读写同一份共享资源时，可能会引起冲突。所以引入线程“同步”机制，

即各线程间要有先来后到；

同步就是排队+锁：

几个线程之间要排队，一个个对共享资源进行操作，而不是同时进行操作；

为了保证数据在方法中被访问时的正确性，在访问时加入锁机制

package newday9.maipiao;

import java.net.ServerSocket;
import java.util.Objects;

public class Ticket extends Thread {
    static int num = 10;
     static Object objects = new Object();

    @Override
    public void run() {
        while (true) {
            //setPriority();修饰代码快，
            // 同步对象：多个线程必须是同一个对象
            //同步对象可以是java中的任何类对象
            //setPriority(同步对象);{
            //同步代码块
            //}

            synchronized (objects){
                if (num > 0) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "买到了票" + num);
                    num--;
                } else {
                    break;
                }
            }
        }
    }
}





package newday9.maipiao;

public class Test {
    public static void main(String[] args) {

        Ticket ticket=new Ticket();
        Thread thread1=new Thread(ticket,"窗口1");
        Thread thread2=new Thread(ticket,"窗口2");
        thread1.start();
        thread2.start();
    }



}

同步锁

同步锁可以是任何对象,必须唯一,保证多个线程获得是同一个对象(用

来充当锁标记).

同步执行过程

1.第一个线程访问，锁定同步对象，执行其中代码.

2.第二个线程访问，发现同步对象被锁定，无法访问.

3.第一个线程访问完毕，解锁同步对象.

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

Lock（锁）

package newday9.suomaipiao;

public class Suo extends Thread{

    static int num=10;

    @Override
    public void run() {
        while (true) {
            A();
        }
    }
//出票的方法：
    //synchronized修饰方法，同步对象默认
    //synchronized修饰非静态方法同步对象为this
    //synchronized修饰的为静态方法时，同步对象是当前类的Class对象
    public static synchronized void A (){
        if (num > 0) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "买到了票" + num);
            num--;
        }

    }
}

线程通信

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

涉及三个方法：

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

notify一旦执行此方法，就会唤醒被wait的一个线程。如果有多个线程被wait，

就唤醒优先级高的那个。

notifyAll一旦执行此方法，就会唤醒所有被wait的线程。

注意：

wait（），notify（），notifyAll（）三个方法必须使用在同步代码块或同步方

法中。

package newday9.dome;

public class Counter {
    int num=1;

    public synchronized void add()  {
        if(num==0){
            num=1;
            System.out.println("生产");
            this.notify();//唤醒消费者线程
        }else{
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public synchronized void sub() {
        if(num==1){
            num=0;
            System.out.println("消费");
            this.notify();//唤醒生产者
        }else{
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}