目录
创建三个窗口卖票，总票数为100张，使用继承Thread类的方式
创建三个窗口卖票，总票数为100张，使用实现Runable接口的方式
并行与并发的理解
并行：多个CPU同时执行多个任务。比如：多个人同时做不同的事。
并发：一个CPU(采用时间片)同时执行多个任务。比如：秒杀、多个人做同一件事
多线程的优点
以单核CPU为例，只使用单个线程先后完成多个任务，比使用多个线程来完成用的时间更短
- 提高应用程序的响应。对图形化界面更有意义，可增强用户体验
- 提高计算机系统CPU的利用率
- 改善程序结构。将既长又复杂的进程分为多个线程，独立运行，利于理解和修改
何时需要多线程
-
程序需要同时执行两个或多个任务
-
程序需要实现一些需要等待的任务
-
需要一些后台运行的程序
创建多线程的方式
多线程的创建：
方式一：继承于Threa类的方式
1.创建一个继承于Thread的子类
2.重写Thread类的run方法 –>此线程执行的操作声明在run()中
3.创建Thread类的子类的对象
4.通过此对象调用start()
//1.创建一个继承于Thread的子类
class MyThread extends Thread{
//2.重写Thread类的run方法
@Override
public void run() {
for(int i =0;i < 100;i++){
if(i % 2 == 0){
System.out.println(Thread.currentThread().getName()+ ":" + i);
}
}
}
}
public class ThreadTest{
public static void main(String[] args) {
//3.创建Thread类的子类的对象
MyThread t1 = new MyThread();
//4.通过此对象调用start()①启动当前线程 ②调用当前线程的run();
//我们不能通过直接调用run()的方式启动线程。同时一个对象不能多次调用start()。
t1.start(); //start可以开启一个新的线程
//System.out.println("hello");
//如下操作仍是在main线程中执行的。
for(int i = 0;i < 100;i++){
if(i % 2 != 0) {
System.out.println(Thread.currentThread().getName()+ ":" + i + " hello");
}
}
}
}创建两个分线程
public class ThreadDemo {
public static void main(String[] args) {
MyThread1 m1 = new MyThread1();
MyThread2 m2 = new MyThread2();
m1.start();
m2.start();
}
}
class MyThread1 extends Thread{
@Override
public void run() {
for(int i =0;i < 100;i++){
if(i % 2 == 0) {
System.out.println(Thread.currentThread().getName()+","+i);
}
}
}
}
class MyThread2 extends Thread{
@Override
public void run() {
for(int i =0;i < 100;i++){
if(i % 2 != 0) {
System.out.println(Thread.currentThread().getName()+","+i);
}
}
}
}线程的调度
高优先级的线程抢占CPU
//线程的优先级：
//如何获取和设置当前线程的优先级：
getPriority():获取线程的优先级
setPriority(int p):设置线程的优先级
//高优先级的线程要抢占低优先级CPU的执行权，但是只从概率上讲，高优先级的线程高概率的情况下被执行。
//并不意味着只有当高优先级的线程执行完以后，低优先级的线程才执行。class HelloThread extends Thread{
@Override
public void run() {
for(int i = 0; i < 100; i++){
if(i % 2 == 0){
System.out.println(Thread.currentThread().getName()+" "+Thread.currentThread().getPriority() + ":"+i);
}
if(i % 20 == 0){
yield();//释放当前cpu的执行权
}
}
}
public HelloThread(String name){
super(name);
}
}
public class ThreadMethodTest {
public static void main(String[] args) {
HelloThread h1 = new HelloThread("Thread01");
//h1.setName("线程一");
//设置分线程的优先级
h1.setPriority(Thread.MAX_PRIORITY);
h1.start();
//给主线程命名
Thread.currentThread().setName("主线程");
Thread.currentThread().setPriority(Thread.MIN_PRIORITY);
for(int i = 0; i < 100; i++){
if(i % 2 == 0){
System.out.println(Thread.currentThread().getName()+","+Thread.currentThread().getPriority()+":"+i);
}
if(i == 20){
try {
h1.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
System.out.println(h1.isAlive());
}
}* 测试Thread类中的常用方法：
* 1.start():启动当前线程；调用当前线程的run()
* 2.run():通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中
* 3.currentThread():静态方法，返回当前代码执行的线程
* 4.getName():获取当前线程的名字
* 5.setName():设置当前线程的名字
* 6.yield();释放当前cpu的执行权
* 7.join():在线程a中调用线程b的join()，此时线程a就进入阻塞状态，直到线程b完全执行完以后，线程a才结束阻塞状态。
* 8.sleep(long millitime):让当前线程”睡眠“指定的millitime毫秒。在指定的millitime毫秒时间内，当前线程是阻塞状态。
* 9.isAlive():确认当前线程是否还存活。创建三个窗口卖票，总票数为100张，使用继承Thread类的方式
class Window extends Thread{
private static int ticket = 100;
@Override
public void run() {
while(true){
if(ticket>0){
System.out.println(Thread.currentThread().getName()+"：卖票；票号为："+ticket);
ticket--;
}else{
break;
}
}
}
}
public class WindowTest {
public static void main(String[] args) {
Window t1 = new Window();
Window t2 = new Window();
Window t3 = new Window();
t1.setName("窗口一");
t2.setName("窗口二");
t3.setName("窗口三");
t1.start();
t2.start();
t3.start();
}
}创建多线程的方式二
* 创建多线程的方式二：实现Runable接口
* 1.创建一个实现了Runable接口的类
* 2.实现类去实现Runable中的抽象方法：run()
* 3.创建实现类的对象
* 4.将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
* 5.通过Thread类的对象调用start()
*
* 比较创建线程的两种方式。
* 开发中：优先选择：实现Runnable接口的方式
* 1.实现的方式没有类的单继承性的局限性
* 2.实现的方式更适合来处理多个线程有共享数据的情况。
*
* 联系：pubLic class Thread implements Runnable
* 相同点：两种方式都需要重写run(),将线程要执行的逻辑声明在run()中class MThread implements Runnable{
//2.实现类去实现Runable中的抽象方法：run()
@Override
public void run() {
for(int i = 0;i < 100;i++){
if(i % 2 == 0){
System.out.println(Thread.currentThread().getName()+"是"+i);
}
}
}
}
public class ThreadTest1 {
public static void main(String[] args) {
//3.创建实现类的对象
MThread mThread = new MThread();
//4.将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
Thread t1 = new Thread(mThread);
t1.setName("线程1");
//5.通过Thread类的对象调用start()①启动线程 ②调用当前线程的run()方法-->调用了Runable类型的target的run方法
t1.start();
//再启动一个线程，，遍历100以内的偶数；我们必须重新创建一个线程的对象
Thread t2 = new Thread(mThread);
t2.setName("线程2");
t2.start();
}
}创建三个窗口卖票，总票数为100张，使用实现Runable接口的方式
class Window1 implements Runnable{
private int ticket = 100;
@Override
public void run() {
while (true){
if(ticket>0){
System.out.println(Thread.currentThread().getName() + ",卖票，票号为："+ticket);
ticket--;
}else{
break;
}
}
}
}
public class WindowTest1 {
public static void main(String[] args) {
Window1 w = new Window1(); //创建实现类的对象
Thread t1 = new Thread(w);//线程是new出来的同一个对象再次建出来的，所以ticket不用再用static修饰
Thread t2 = new Thread(w);
Thread t3 = new Thread(w);
t1.setName("窗口一");
t2.setName("窗口二");
t3.setName("窗口三");
t1.start();
t2.start();
t3.start();
}
}JDK5.0新增线程创建方式
实现Callable接口
/**
* 创建线程的方式三：实现Callable接口。 --- JDK 5.0新增
*
*
* 如何理解实现Callable接口的方式创建多线程比实现Runnable接口创建多线程方式强大？
* 1. call()可以有返回值的。
* 2. call()可以抛出异常，被外面的操作捕获，获取异常的信息
* 3. Callable是支持泛型的
*
*/
//1.创建一个实现Callable的实现类
class NumThread implements Callable{
//2.实现call方法，将此线程需要执行的操作声明在call()中
@Override
public Object call() throws Exception {
int sum = 0;
for (int i = 1; i <= 100; i++) {
if(i % 2 == 0){
System.out.println(i);
sum += i;
}
}
return sum;
}
}
public class ThreadNew {
public static void main(String[] args) {
//3.创建Callable接口实现类的对象
NumThread numThread = new NumThread();
//4.将此Callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象
FutureTask futureTask = new FutureTask(numThread); //FutureTask是Future接口的唯一实现类
//FutureTask已经实现了Runnable()接口
//5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
new Thread(futureTask).start();
try {
//6.获取Callable中call方法的返回值
//get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值。
Object sum = futureTask.get();
System.out.println("总和为：" + sum);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}使用线程池
- 经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大
- 提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用
- 好处：①提高响应速度（减少了创建新线程的时间）；②降低资源消耗（重复利用线程池中线程，不需要每次都创建）；③便于线程管理
/**
* 创建线程的方式四：使用线程池
*
* 好处：
* 1.提高响应速度（减少了创建新线程的时间）
* 2.降低资源消耗（重复利用线程池中线程，不需要每次都创建）
* 3.便于线程管理
* corePoolSize：核心池的大小
* maximumPoolSize：最大线程数
* keepAliveTime：线程没有任务时最多保持多长时间后会终止
*
*Executors.newCachedThreadPool():创建一个可根据需要创建新线程的线程池
* Executors.newFixedThreadPool(n):创建一个可重用固定线程数的线程池
* Executors.newSingleThreadExecutor():创建一个只有一个线程的线程池
* Executors.newScheduledThreadPool(n):创建一个线程池，它可安排在给定延迟后执行命令或者定期地执行
*
* 面试题：创建多线程有几种方式？四种！
* @author shkstart
* @create 2019-02-15 下午 6:30
*/
class NumberThread implements Runnable{
@Override
public void run() {
for(int i = 0;i <= 100;i++){
if(i % 2 == 0){
System.out.println(Thread.currentThread().getName() + ": " + i);
}
}
}
}
class NumberThread1 implements Runnable{
@Override
public void run() {
for(int i = 0;i <= 100;i++){
if(i % 2 != 0){
System.out.println(Thread.currentThread().getName() + ": " + i);
}
}
}
}
public class ThreadPool {
public static void main(String[] args) {
//1. 提供指定线程数量的线程池
ExecutorService service = Executors.newFixedThreadPool(10);
ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;
//设置线程池的属性
// System.out.println(service.getClass());
// service1.setCorePoolSize(15);//核心池的大小
// service1.setKeepAliveTime();//线程没有任务时最多保持多长时间后终止
//2.执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象
service.execute(new NumberThread());//适合适用于Runnable
service.execute(new NumberThread1());//适合适用于Runnable
// service.submit(Callable callable);//适合使用于Callable
//3.关闭连接池
service.shutdown();
}
}版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 举报，一经查实，本站将立刻删除。
文章由极客之音整理，本文链接：https://www.bmabk.com/index.php/post/83245.html
