首页 > 系统相关> 文章详细

进程和线程

2022-01-16 21:36:28 阅读：158 来源： 互联网

标签：优先级 Thread MyThread 线程进程 new public

1.进程

进程：是正在运行的程序

是系统进行资源分配和调用的独立单位
每一个进程都有它自己的内容空间和系统资源

2.线程

线程：是进程中的单个顺序控制流，是一条执行路径

单线程：一个进程如果只有一条执行路径，则称为单线程程序
多线程：一个进程如果有多条执行路径，则称为多线程程序

多线程的实现方式一：

通过继承Thread类的方式实现多线程

定义一个类继承Thread类
在该类中重写run()方法
创建该类的对象
启动线程

public class MyThread extends Thread{
    public MyThread(){}
    public MyThread(String name){
        super(name);
    }
    
    @Override
    public void run(){
        for(int i=0;i<100;i++){
            System.out.println(getName()+":"+i);
        }
    }
}

public class MyRunnableDemo{
    public static void main(String[] args){
        //MyThread my1 = new MyThread();
        //MyThread my2 = new MyThread();
        MyThread my1 = new MyThread("线程1");
        MyThread my2 = new MyThread("线程2");
        
        my1.start();
        my2.start();
    }
}

线程优先级

线程有两种调度模型：

分时调度模型：所有线程轮流使用CPU的使用权，平均分配每个线程占用CPU的时间片
抢占式调度模型：优先让优先级高的线程使用CPU，如果线程的优先级相同，那么会随机选择一个，优先级高的线程获取CPU时间片相对多一些
Java使用的是抢占式调度模型

Thread 类中设置和获取线程优先级的方法：

public final int getPriority()：返回此线程的优先级
public final void setPriority(int newPriority)：更改此线程的优先级

线程优先级的常量：

Thread.MAX_PRIORITY：最高优先级为 10
Thread.MIN_PRIORITY：最低优先级为 1
Thread.NORM_PRIORITY：默认优先级为 5

线程控制：

线程生命周期：

多线程的实现方式二：

通过实现Runnable接口的方式实现多线程

定义一个类实现Runnable接口
在该类中重写run()方法
创建该类的对象
创建Thread类的对象，把该类对象作为构造方法的参数
启动线程

public class MyRunnable implements Runnable{
    @Override
    public void run(){
        for(int i=0;i<100;i++){
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}

public class MyRunnableDemo{
    public static void main(String[] args){
        MyRunnable my = new MyRunnable();
        
        //Thread t1 = new Thread(my);
        //Thread t2 = new Thread(my);
        Thread t1 = new Thread(my,"线程1");
        Thread t2 = new Thread(my,"线程2");
        
        t1.start();
        t2.start();
    }
}

多线程实现的两种方式的区别：

相比继承Thread类，实现Runnable接口的好处

避免了Java单继承的局限性
适合多个相同程序的代码去处理同一个资源的情况，把线程和程序的代码、数据有效分离，较好的体现了面向对象的设计思想

3.线程同步

（1）同步代码块

（2）同步方法

（3）线程安全的类

（4）Lock锁

Lock实现提供比使用synchronized方法和语句可以获得更广泛的锁定操作

Lock中提供了获取锁和释放锁的方法：

void lock()：获得锁
void unlock()：释放锁

Lock是接口不能直接实例化，这里采用它的实现类ReentrantLock来实例化

ReentrantLock的构造方法：

ReentrantLock()：创建一个ReentrantLock的实例

public class SellTicket implements Runnable{
    private int tickets = 100; //票数
    private Lock lock = new ReentrantLock();
    
    @Override
    public void run(){
        while(true){
            try{
                lock.lock();
                if(tickets>0){
                    try{
                        Thread.sleep(100);
                    }catch(InterruptedException e){
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+"正在出售第"+tickets+"张票");
                    tickets--;
                }
            }finally{
            	lock.unlock();
            }
        }
    }
}

public class SellTicketDemo{
    public static void main(String[] args){
        SellTicket st = new SellTicket();
        
        Thread t1 = new Thread(st,"窗口1");
        Thread t2 = new Thread(st,"窗口2");
        Thread t3 = new Thread(st,"窗口3");
        
        t1.start();
        t2.start();
        t3.start();
    }
}

标签：优先级,Thread,MyThread,线程,进程,new,public
来源： https://www.cnblogs.com/onesun/p/15811318.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9