JAVA多线程的基本知识点总结

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

文章目录

• 前言
• 一、pandas是什么？
• 二、使用步骤
  • 1.引入库
  • 2.读入数据
• 总结

---

前言

       要了解线程就必须了解进程，进程是一个正在执行的程序。而线程是一个进程内的单个顺序控制流，是一条执行路径。多线程是可以更好的使用cpu的资源，提升程序的执行效率，实现一些特有的功能。同时因为创建一个线程要比创建一个进程所消耗的资源少，从而实现以较少的资源实现较多的功能。

一、多线程的实现

多线程的常用实现方法有两种：

1，继承Thread类，在Thread类中重写run方法，在main方法中myThread新建对象即可实现多线程

public class myThread extends Thread {

    @Override
    public void run() {
        for (int i = 0; i <10; i++) {
            System.out.println(i);
            try {
                sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }
}

2，实现runable接口，同样也需要重写run方法，也需要在main方法中新建对象，在新建Thread类对象。

public class itma implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(i);
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }


    }
}

public class itheima {
    public static void main(String[] args) throws IOException {
        itma t = new itma();
     Thread t1=new Thread(t);
     Thread t2=new Thread(t);
     Thread t3=new Thread(t);
     t1.start();
     t2.start();
     t3.start();


    }

}

二、线程的调度

       线程的调度方式有两种，其一是抢占式调度，线程的执行权是随机分配优先级越高得到执行权的可能越大。还有一种是分时调度方式即所有线程平均使用执行权。

       在抢占式调度的调度方式下可以改变线程的优先级来提高相应线程的执行概率，同时也可以通过查看优先级的方法来得到线程优先级。

public class itheima {
    public static void main(String[] args) throws IOException {
        itma t = new itma();
        Thread t1 = new Thread(t);
        Thread t2 = new Thread(t);
        Thread t3 = new Thread(t);
        //设置线程优先级
        t1.setPriority(10);
        t2.setPriority(5);
        t3.setPriority(1);

        //查看线程优先级
        t1.getPriority();
        t2.getPriority();
        t3.getPriority();
        //线程执行
        //     t1.start();
        //     t2.start();
        //     t3.start();

    }

}

     java 的线程的默认优先级都是5其设置的范围是1-10；10并不是指全部执行此线程只是表示一种概率较大而已。

三、线程锁

线程锁可以保证多线程操作同一个数据时的数据安全问题，其分为隐式锁和显示锁。

1.隐式锁

隐式锁可以是同步代码快和线程安全的方法，3种方式两种锁这两种方式都要用到关键字synchronized其中同步代码块要用到的锁为

public class itma implements Runnable {
    private int ticket=100;
    private Object obj=new Object();
    @Override
    public void run() {
     while (true){
         synchronized (obj){
             if (ticket>0){
                 try {
                     Thread.sleep(100);
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }
                 System.out.println(Thread.currentThread().getName()+"第"+ticket+"张票");
                 ticket--;
             }
         }

     }



    }

}

而线程安全的方法分为synchronized修饰的方法和非synchronized修饰的方法，其中非synchronized修饰的类其锁为synchronized（this）

public class itma implements Runnable {

    private int ticket = 100;
    private Object obj = new Object();
    private int x = 0;

    @Override
    public void run() {
        while (true) {
            if (x % 2 == 0) {
                synchronized (this) {
                    if (ticket > 0) {
                        try {
                            Thread.sleep(100);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println(Thread.currentThread().getName() + "第" + ticket + "张票");
                        ticket--;
                    }
                }
            } else {

                    sellTicket();

            }
            x++;
        }
    }

    public synchronized void sellTicket() {//sychromized修饰的方法
            if (ticket > 0) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "第" + ticket + "张票");
                ticket--;
            }
    }
}

其中非synchronized修饰的方法为synchronized（obj）

2.显示锁

显示锁较为方便和简单无需关键字但需要借助ReentrantLock()来实现实例化，而且还要实unlock方法来结束锁。

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class itma implements Runnable {

    private int ticket = 100;
    private Lock lc = new ReentrantLock();

    @Override
    public void run() {
        while (true) {
            lc.lock();
            if (ticket > 0) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "第" + ticket + "张票");
                ticket--;
            }
            lc.unlock();


        }
    }

}

显示锁在使用时更加的灵活和方便

总结

以上就是多线程的有关知识点的总结

。