1.请简单描述什么是并行，什么是并发?
并行：指两个或多个事件在同一时刻发生（同时发生）。
并发：指两个或多个事件在同一个时间段内发生。
通俗易懂版：
你吃饭吃到一半，电话来了，你一直到吃完了以后才去接，这就说明你不支持并发也不 支持并行。
你吃饭吃到一半，电话来了，你停了下来接了电话，接完后继续吃饭，这说明你支持并发。
你吃饭吃到一半，电话来了，你一边打电话一边吃饭，这说明你支持并行。
并发的关键是你有处理多个任务的能力，不一定要同时。
并行的关键是你有同时处理多个任务的能力。
所以它们最关键的点就是：是否是『同时』。
2.请描述什么是进程，什么是线程，进程与线程之间的关系，并举例说明。
进程指正在运行的程序。确切的来说，当一个程序进入内存运行，即变成一个进程，进程是处于运行过程中的程序，并且具有一定独立功能。
线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。
一个程序运行后至少有一个进程，一个进程中可以包含多个线程,但一个进程中至少包含一个线程。比如使用迅雷软件下载网络文件时，同时下载多个文件，就使用到了多线程下载。
3.自定义异常类
每一个学生(Student)都有学号,姓名和分数,分数永远不能为负数
如果老师给学生赋值一个负数,抛出一个自定异常
/* 1.定义异常类NoScoreException,继承RuntimeException a)提供空参和有参构造方法 */ public class NoScoreException extends RuntimeException { // 空参构造 public NoScoreException() { super(); } // 有参构造 public NoScoreException(String message) { super(message); } }
/* 2.定义学生类(Student) a)属性:name,score b)提供空参构造 c)提供有参构造; i.使用setXxx方法给名称和score赋值 d)提供setter和getter方法 i.在setScore(int score)方法中 1.首先判断,如果score为负数,就抛出NoScoreException,异常信息为:分数不能为负数:xxx. 2.然后在给成员score赋值. */ public class Student { private String name; private int score; // 空参构造 public Student() { super(); } // c)提供有参构造; // i.使用setXxx方法给名称和score赋值 public Student(String name,int score){ setName(name); setScore(score); } // d)提供setter和getter方法 public String getName() { return name; } public void setName(String name) { this.name = name; } public int getScore() { return score; } // i.在setScore(int score)方法中 public void setScore(int score) { // 1.首先判断,如果score为负数,就抛出NoScoreException,异常信息为:分数不能为负数:xxx. if(score <0){ throw new NoScoreException(":分数不能为负数:"+score); } // 2.然后在给成员score赋值. this.score = score; } }
/* 3.定义测试类Test9 a)提供main方法,在main方法中 i.使用满参构造方法创建Student对象,分数传入一个负数,运行程序 ii.由于一旦遇到异常,后面的代码的将不在执行,所以需要注释掉上面的代码 iii.使用空参构造创建Student对象 iv.调用setScore(int score)方法,传入一个正数,运行程序 v.调用setScore(int score)方法,传入一个负数,运行程序 */ public class Test9 { public static void main(String[] args) { // i.使用满参构造方法创建Student对象,分数传入一个负数,运行程序 // Student s = new Student("景甜", -10); // ii.由于一旦遇到异常,后面的代码的将不在执行,所以需要注释掉上面的代码 // iii.使用空参构造创建Student对象 Student s = new Student(); // iv.调用setScore(int score)方法,传入一个正数,运行程序 s.setScore(100); // v.调用setScore(int score)方法,传入一个负数,运行程序 s.setScore(-5); } }
4.创建多线程对象，开启多线程。在子线程中输出1-100之间的偶数，主线程输出1-100之间的奇数。
//自定义线程类： public class MyThread extends Thread { /** * 重写run方法，完成该线程执行的逻辑 */ @Override public void run() { for (int i = 1; i <= 100; i++) { if (i % 2 == 0) { System.out.println("子线程打印输出偶数：" + i); } } } }
//测试类： public class Test11 { public static void main(String[] args) { //创建自定义线程对象 MyThread mt = new MyThread(); //开启线程 mt.start(); //在主方法中执行for循环 for (int i = 1; i <= 100; i++) { if (i % 2 == 1) { System.out.println("主线程打印输出奇数：" + i); } } } }
5.
创建三个子线程，在每个线程中开启10万次的循环，线程1循环中将循环自增变量i赋值给Integer类型变量 a，线程2循环中将字符串"程序员"赋值给String类型变量b,线程3循环中将字符串"程序员"和循环自增变量i拼接后赋值给String类型变量c
分别计算三个线程完成任务所用的毫秒值
//线程1 public class Thread1 extends Thread{ @Override public void run() { long start = System.currentTimeMillis(); for (int i = 0; i < 100000; i++) { Integer a = i; } long end = System.currentTimeMillis(); System.out.println("线程1执行时间："+(end-start)); } }
//线程2 public class Thread2 extends Thread{ @Override public void run() { long start = System.currentTimeMillis(); for (int i = 0; i < 100000; i++) { String b = "程序员"; } long end = System.currentTimeMillis(); System.out.println("线程2执行时间："+(end-start)); } }
//线程3 public class Thread3 extends Thread{ @Override public void run() { long start = System.currentTimeMillis(); for (int i = 0; i < 100000; i++) { String c = "程序员"+i; } long end = System.currentTimeMillis(); System.out.println("========线程3执行时间："+(end-start)); } }
//测试类 public class TestThread { public static void main(String[] args) { new Thread1().start(); new Thread2().start(); new Thread3().start(); } }
6.请描述Thread类中的start()方法与run()方法的区别。
答：
线程对象调用run()方法不开启线程，仅是对象调用方法。线程对象调用start()方法开启线程，并让jvm调用run()方法在开启的线程中执行。
7.请描述创建线程的两种方式。
答：
第一种方式是将类声明为 Thread 的子类。
- 定义Thread类的子类，并重写该类的run()方法，该run()方法的方法体就代表了线程需要完成的任务,因此把run()方法称为线程执行体。
- 创建Thread子类的实例，即创建了线程对象。
- 调用线程对象的start()方法来启动该线程。
第二种方式是声明一个类实现Runnable 接口。
1. 定义Runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。
2. 创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，Thread对象才是真正的线程对象。
3. 调用线程对象的start()方法来启动线程。
8.请编写程序，分别打印主线程的名称和子线程的名称。
要求使用两种方式实现：
第一种方式：继承Thread类。
第二种方法：实现Runnable接口。
// 第一种方式：继承Thread类 /* * 1.定义一个子线程的类，继承Thread类； */ public class SubThread extends Thread { /* *2.在子线程类中重写run方法，在run方法中打印子线程的名称； */ public void run() { // 打印子线程的名称 System.out.println("subThread:" + Thread.currentThread().getName()); } } /* * 3.定义一个测试类 */ public class ThreadDemo { public static void main(String[] args) { // 4.在main方法中打印主线程的名称； System.out.println("main:" + Thread.currentThread().getName()); // 5.在main方法中创建子线程对象； SubThread st = new SubThread(); // 6.调用子线程对象的start方法，开启子线程。 st.start(); } }
// 第二种方式：实现Runnable接口 /* * 1.定义一个子任务类，实现Runnable接口。 */ public class SubRunnable implements Runnable { @Override public void run() { // 2.在子任务类中重写run方法，在run方法中打印子线程的名称。 System.out.println("SubRunnable:"+ Thread.currentThread().getName()); } } /* * 3.定义一个测试类。 */ public class RunnableDemo { public static void main(String[] args) { // 4.在main方法中打印主线程的名称。 System.out.println("RunnableDemo:"+ Thread.currentThread().getName()); // 5.在main方法中创建一个子任务对象。 SubRunnable r = new SubRunnable(); // 6.在main方法中创建一个Thread类的对象，并把子任务对象传递给Thread类的 构造方法。 Thread t = new Thread(r); // 7.调用Thread类对象的start方法开启子线程。 t.start(); } }
9.请描述实现Runnable接口比继承Thread类所具有的优势：
答：
1. 适合多个相同的程序代码的线程去共享同一个资源。
2. 可以避免java中的单继承的局限性。
3. 增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和数据独立。
4. 线程池只能放入实现Runable或callable类线程，不能直接放入继承Thread的类。
10.请描述在线程的生命周期中， 有几种状态呢
答：
- NEW(新建) 线程刚被创建，但是并未启动。
- Runnable(可运行)
线程可以在java虚拟机中运行的状态，可能正在运行自己代码，也可能没有，这取决于操作系统处理器。
- Blocked(锁阻塞)
当一个线程试图获取一个对象锁，而该对象锁被其他的线程持有，则该线程进入Blocked状态；当该线程持有锁时，该线程将变成Runnable状态。
- Waiting(无限等待)
一个线程在等待另一个线程执行一个（唤醒）动作时，该线程进入Waiting状态。进入这个状态后是不能自动唤醒的，必须等待另一个线程调用notify或者notifyAll方法才能够唤醒。
- Timed Waiting(计时等待)
同waiting状态，有几个方法有超时参数，调用他们将进入Timed Waiting状态。这一状态将一直保持到超时期满或者接收到唤醒通知。带有超时参数的常用方法有Thread.sleep 、Object.wait。
- Teminated(被终止)
因为run方法正常退出而死亡，或者因为没有捕获的异常终止了run方法而死亡。