关于java:多线程-实现多线程

2次阅读

共计 3824 个字符，预计需要花费 10 分钟才能阅读完成。

正在运行的程序

是零碎进行资源分配和调用的独立单位
每一个过程都有它本人的内存空间和系统资源

是过程中的单个顺序控制流，是一条执行门路

单线程 一个过程如果只有一条执行门路，则称为单线程程序
多线程 一个过程如果有多条执行门路，则称为多线程程序

形式 1 继承 Thread 类
1. 定义一个类 MyThread 继承 Thread 类
2. 在 MyThread 类中重写 run()办法
3. 创立 MyThread 类的对象
4. 启动线程

public class MyThread extends Thread{
   // 重写 run 办法
   @Override
   public void run(){for(int i = 0;i<100;i++){System.out.ptintln(i);
      }
   }
}

// 主程序
// 创立 MyThread 对象
MyThread my1 = new MyThread();
MyThread my2 = new MyThread();
// 调用 run 办法并没有启动线程
my1.run();
my2.run();
//start 导致此线程开始执行，java 虚拟机调用此线程的 run 办法
my1.start();
my2.start();

通过 setname 赋值，getname 获取
通过带参构造方法给线程设置名称
通过动态的 currentThread()办法获取以后正在执行线程对象，再用 getname 获取线程名称

public class MyThread extends Thread{
   // 重写 run 办法
   @Override
   public void run(){for(int i = 0;i<100;i++){System.out.ptintln(getName()+":"+i);// 因为是继承 Thread 类，所以能够间接调用 Thread 的 getName()}
   }
}
// 主程序
// 创立 MyThread 对象
MyThread my1 = new MyThread();
MyThread my2 = new MyThread();
// 将此此线程的名称更改为参数 name
//start 导致此线程开始执行，java 虚拟机调用此线程的 run 办法
my1.setName("高铁"); // 给线程设置名称
my2.setName("飞机");

my1.start();
my2.start();

// 下图是带参结构和无参结构
带参构造方法是 thread 类里的，所以要继承 用 super 拜访父类的带参结构
MyThread my1 = new MyThread(name:"高铁");
MyThread my2 = new MyThread(name:"飞机");

想要看 main 办法的线程名称，不能间接用 getname 办法，因为 main 办法没有继承 Thread 类

//currentThread() 返回对以后正在执行的线程对象的援用 是静态方法 
// 所以想要返回 main 办法的线程名称
sout(Thread.currentThread().getName())// 输入就是 main  阐明 main 办法就在 main 这个线程里

分时调度模型：所有线程轮流应用 CPU 的使用权，平均分配每个线程占用 CPU 的工夫片
抢占式调度模型：优先让优先级搞的线程应用 CPU，如果优先级雷同，则随机抉择一个，优先级高的线程获取的 CPU 的工夫片绝对多一些

java 应用的是抢占式调度模型

控制线程的优先级

public class MyThread extends Thread{
   // 重写 run 办法
   @Override
   public void run(){for(int i = 0;i<100;i++){System.out.ptintln(getName()+":"+i);// 因为是继承 Thread 类，所以能够间接调用 Thread 的 getName()}
   }
}
// 主程序
// 创立 MyThread 对象
ThreadPriority tp1 = new ThreadPriority ();
ThreadPriority tp2 = new ThreadPriority ();
ThreadPriority tp3 = new ThreadPriority ();

tp1 .setName("高铁"); // 给线程设置名称
tp2 .setName("飞机");
tp3 .setName("汽车");
// 多线程程序执行随机性 

//getPriority()返回线程的优先级 全都输入 5 这三个线程的优先级一样 所以在执行的时候随机抉择 
// 返回 5 阐明零碎默认优先级是 5
sout(tp1.getPriority());//5
sout(tp2.getPriority());//5
sout(tp3.getPriority());//5

//setPriority()更改线程的优先级
tp1.setPriority(1000);
// 线程优先级更改为 1000 会呈现非法参数异样 IllegalArguementException 
// 阐明给的优先级不在范畴内 范畴是 1 -10 最高优先级是 10 最低优先级是 1
tp1.setPriority(5);
tp2.setPriority(10);
tp3.setPriority(1);
// 线程优先级高，仅仅代表获取 CPU 的工夫片的几率高 而不是每次都跑在最后面

tp1.start();
tp2.start();
tp3.start();

join那个必须是其余所有线程都得期待调用了 join 这个线程执行结束能力运行
setDaemon 如果 boolean 值是 true，就是将这个线程标为守护线程，如果主线程运行完，剩下都是守护线程，那么 java 虚拟机将会退出

public class ThreadSleep extends Thread{
   // 重写 run 办法
   @Override
   public void run(){for(int i = 0;i<100;i++){System.out.ptintln(getName()+":"+i);// 因为是继承 Thread 类，所以能够间接调用 Thread 的 getName()
         Thread.sleep(millis:1000);//alt enter 捕捉异样 
         // 每输入一次就让这个线程休眠 1000ms
      }
   }
}
// 主程序
// 创立 MyThread 对象
ThreadSleep ts1 = new ThreadSleep();
ThreadSleep ts2 = new ThreadSleep();
ThreadSleep ts3 = new ThreadSleep();

ts1 .setName("曹操"); // 给线程设置名称
ts2 .setName("刘备");
ts3 .setName("孙权");

---------
// 设置主线程为诸葛亮
Thread.currentThread().setName("诸葛亮");

// 当主线程完结的时候，其余线程也不必活了
// 就设置守护线程
ts1.setDaemon(true);
ts2.setDaemon(true);
ts3.setDaemon(true);
// 设置下面三个为守护线程，主线程完结了，守护线程也完结 但并不会立刻完结 而是挣扎一下再完结了了 很快就执行结束 不是立刻隐没

----------
ts1.start();
ts1.join();//alt enter 捕捉异样

// 下面 ts1 调用了 join 办法，则只能 ts1 执行结束能力走上面的线程 ts2 ts3
ts2.start();
ts3.start();

for(int i = 0;i<10,i++){sout(Thread.currentThread().setName("诸葛亮")+":"+i);// 诸葛亮执行到 9
}

sleep 办法

join 办法

后面的线程执行结束，能力执行前面的线程

实现 Runnable 接口
1. 当以一个类 MyRunnable 实现 Runnable 接口
2. 在 MyRunnable 类中重写 run()办法
3. 创立 MyRunnable 类的对象
4. 创立 Thread 类的对象，把 MyRunnable 对象作为构造方法的参数
5. 启动线程

// 自定义的 MyRunnable 类
public class MyRunnable implements Runnable{
   // 重写 run 办法
   @Override
   public void run(){for(int i = 0;i<100;i++){System.out.ptintln(getName()+":"+i);// 因为是用的 Runnable 接口，不是 Thread 类，所以不能间接调用 Thread 的 getName()
         // 下面的应该改为
         System.out.ptintln(Thread.currentThread().getName()+":"+i);// 拿到以后执行的线程
      }
   }
}
// 主程序
// 创立 MyRunnable 对象
MyRunnable my = new MyRunnable();
// 创立 Thread 类的对象，把 MyRunnable 对象作为构造方法的参数
//Thread(Runnable target) 默认参数名 无参结构
Thread t1 = new Thread(my);
Thread t2 = new Thread(my);

// 有参结构 设置线程名称
Thread t1 = new Thread(my,name:"高铁");
Thread t2 = new Thread(my,name:"飞机");

// 启动线程
t1.start();
t2.start();

接口不影响继承其余类，MyRunnable 相当于一个资源，能够有多个线程调用

正文完