java基础面试题整理3-线程

1.进程和线程

1.进程

进程就是正在运行的程序,它代表了程序所占用的内存区域

2.进程的特点

1).独立性
进程是系统中独立存在的实体,它可以拥有自己独立的资源,每个进程都拥有自己私有的地址空间,在没有经过进程本身允许的情况下,一个用户进程不可以直接访问其他进程的地址空间
2).动态性
进程与程序的区别在于,程序只是一个静态的指令集合,而进程是一个正在系统中活动的指令集合,程序加入了时间的概念以后,称为进程,具有自己的生命周期和各种不同的状态,这些概念都是程序所不具备的.
3).并发性
多个进程可以在单个处理器CPU上并发执行,多个进程之间不会互相影响.

3.线程

线程是操作系统OS能够进行运算调度的最小单位,它被包含在进程之中,是进程中的实际运作单位.
一个进程可以开启多个线程,其中有一个主线程来调用本进程中的其他线程
我们看到的进程的切换,切换的也是不同进程的主线程
多线程扩展了多进程的概念,使的同一个进程可以同时并发处理多个任务

4.进程和线程的关系

一个操作系统中可以有多个进程,一个进程中可以包含一个线程(单线程程序),也可以包含多image.png
每个线程在共享同一个进程中的内存的同时,又有自己独立的内存空间.
所以想使用线程技术,得先有进程,进程的创建是OS操作系统来创建的,一般都是C或者C++完成
image.png

5.线程的状态

1.线程的五态模型
image.png
1).创建状态:线程的创建比较复杂,需要先申请PCB,然后为该线程运行分配必须的资源,并将该线程转为就绪状态插入到就绪队列中
2).就绪(可运行)状态:线程已经准备好运行,只要获得CPU,就可立即执行
3).执行(运行)状态:线程已经获得CPU,其程序正在运行的状态
4).阻塞状态:正在运行的线程由于某些事件(I/O请求等)暂时无法执行的状态,即线程执行阻塞
5).终止状态:等待OS进行善后处理,最后将PCB清零,并将PCB返回给系统

  就绪 → 执行:为就绪线程分配CPU即可变为执行状态.
  执行 → 就绪:正在执行的线程由于时间片用完被剥夺CPU暂停执行,就变为就 
         绪状态.
  执行 → 阻塞:由于发生某事件,使正在执行的线程受阻,无法执行,则由执行 
         变为阻塞.
  (例如线程正在访问临界资源,而资源正在被其他线程访问)
  反之,如果获得了之前需要的资源,则由阻塞变为就绪状态,等待分配CPU再次 
  执行.

2.线程状态与代码对照
image.png
线程生命周期,主要有五种状态:
1).新建状态(New) : 当线程对象创建后就进入了新建状态.如:Thread t = new MyThread();
2).就绪状态(Runnable):当调用线程对象的start()方法,线程即为进入就绪状态.
处于就绪(可运行)状态的线程,只是说明线程已经做好准备,随时等待CPU调度执行,并不是执行了t.start()此线程立即就会执行
3).运行状态(Running):当CPU调度了处于就绪状态的线程时,此线程才是真正的执行,即进入到运行状态.就绪状态是进入运行状态的唯一入口,也就是线程想要进入运行状态状态执行,先得处于就绪状态
4).阻塞状态(Blocked):处于运状态中的线程由于某种原因,暂时放弃对CPU的使用权,停止执行,此时进入阻塞状态,直到其进入就绪状态才有机会被CPU选中再次执行.
*根据阻塞状态产生的原因不同,阻塞状态又可以细分成三种:
---等待阻塞:运行状态中的线程执行wait()方法,本线程进入到等待阻塞状态
---同步阻塞:线程在获取synchronized同步锁失败(因为锁被其他线程占用),它会进入同步阻塞状态
---其他阻塞:调用线程的sleep()或者join()或发出了I/O请求时,线程会进入到阻塞状态.当sleep()状态超时.join()等待线程终止或者超时或者I/O处理完毕时线程重新转入就绪状态
5).死亡状态(Dead):线程执行完了或者因异常退出了run()方法,该线程结束生命周期

6.你知道的线程的方法?

1.join():合并当前线程相当于方法的调用
2.yield():让出CPU
3.wait():使一个线程处于等待状态,并且释放所持有的对象lock
4.sleep():是线程类Thread方法,导致线程暂停,然后给定时间,让出cpu给其他线程,但是不会释放对象锁,时间到了恢复。
5.notify():唤醒一个处于等待状态的线程,注意这里不是给所有唤醒线程一个对象的锁 而是让他们竞争。

7.实现多线程的两种方式

1.继承Thread类

public class Test1_Thread {
    public static void main(String[] args) {
        MyThread t1 = new MyThread();
        t1.start();
        MyThread t2 = new MyThread();
        t2.start();
        MyThread t3 = new MyThread("cryin");
        t3.start();    
    }
}

class MyThread extends Thread{
    public MyThread() {
        super();
        // TODO Auto-generated constructor stub
    }
    public MyThread(String name) {
        super(name);
        // TODO Auto-generated constructor stub
    }
    @Override
    public void run() {
        for (int i=0;i<10;i++) {
            System.out.println(i+"="+getName());
        }
    }
}

2.实现Runnable接口

public class Test2_Thread2 {
    public static void main(String[] args) {
        MyRunnable target= new MyRunnable();    
        Thread t1=new Thread(target);
        t1.start();
        Thread t2=new Thread(target,"lulu");
        Thread t3=new Thread(target,"mumu");
        t2.start();
        t3.start();
    }
}

class MyRunnable implements Runnable{
    @Override
    public void run() {
        // TODO Auto-generated method stub
        for(int i=0;i<=9;i++) {
                    System.out.println(i+"="+Thread.currentThread());
        }
    }
}

**多线程的两种实现方式的区别:
1.Thread是Runnable接口的子类,实现Runnable接口的方式解决了Java单继承的局限
2.Runnable接口实现多线程比继承Thread类更加能描述数据共享的概念
注意:通过实现Runnable接口解决了Java单继承的局限,所以不管其他的区别联系是什么,这一点就决定了多线程最好是通过实现Runnable接口的方式

8.实现线程安全的两种方式

*多线程安全问题是如何出现的?常见的情况是由于线程的随机性+访问延迟.
*如何判断线程有没有线程安全问题?多线程程序中+有共享数据+多条语句操作共享数据
1).synchornized方法实现线程同步方法(synchronized机制在执行完相应的同步代码以后,自动的释放同步监视器):

public class ThreadBankTest {
    public static void main(String[] args) {
        Account account = new Account(0);
        Customer customer = new Customer(account);
        Customer customer2 = new Customer(account);
        customer.setName("甲");
        customer2.setName("乙");
        customer.start();
        customer2.start();
    }
}
class Customer extends Thread {
    private Account account;
    public Customer(Account account) {
        this.account = account;
    }
    @Override
    public void run() {
        for (int i = 0; i < 3; i++) {
            account.deposit(1000);
        }
    }
}
class Account {
    private int balance;
    public Account(int balance) {
        this.balance = balance;
    }
    //存钱
    public synchronized void deposit(int money) {
        if (money > 0) {
            balance += money;        
            System.out.println(Thread.currentThread().getName()+"存钱成功"+balance);
        }
    }
}

2).Lock实现线程同步的方法(lock需要手动的启动同步(Lock()),同时结束同步也需要使用手动的实现(unlock()):

public class ThreadBankTest2 {
    public static void main(String[] args) {
        Account2 account2 = new Account2(0);
        Customer2 customer = new Customer2(account2);
        Customer2 customer2 = new Customer2(account2);
        customer.setName("甲");
        customer2.setName("乙");
        customer.start();
        customer2.start();
    }
}
class Customer2 extends Thread {
    private Account2 account;
    public Customer2(Account2 account) {
        this.account = account;
    }
    @Override
    public void run() {
        for (int i = 0; i < 3; i++) {
            account.deposit(1000);
        }
    }
}
class Account2 {
    private int balance;
    //1.实例化ReentrantLock
    private ReentrantLock lock = new ReentrantLock();

    public Account2(int balance) {
        this.balance = balance;
    }
    //存钱
    public void deposit(int money) {
        try {
            //2.调用lock方法:要把要同步的代码放入到try中,try后面的代码就是要实现同步代码
            lock.lock();
            if (money > 0) {
                balance += money;               
                System.out.println(Thread.currentThread().getName()+"存钱成功"+balance);
            }
        } finally {
            //3.给lock解锁unlock
            lock.unlock();
        }
    }
}

评论

暂无评论