package java1;
/**
* 多线程的创建,方式1:继承于Thread类
* 1.创建一个继承于thread类的子类
* 2.重写Thread的run方法->将此线程执行的操作生命在run方法中
* 3.创建Thread类的子类对象
* 4.通过此对象调用start()方法
* 例子:遍历100以内的偶数
* @author Baobao
* @create 2021-07-31 10:11
*/
class MyThread extends Thread{
//重写run
@Override
public void run() {
for (int i = 0; i < 100; i++) {
if(i%2==0){
System.out.println(i);
}
}
}
}
public class ThreadTest {
public static void main(String[] args) {
MyThread m=new MyThread();
//通过当前对象调用start的作用:
//1.启动当前线程
//2.调用当前线程的run方法,如果直接调用run,体现的是对象调用方法,没有开启新的线程
m.start();
}
}
package java1;
/**
*
*测试Thread中的常用方法
* 1.start:启动当前线程,调用当前线程的run()方法
* 2.run():通常需要重写thread中的此方法,将创建的线程执行的操作声明在此方法中
* 3.currentThread():静态方法,返回当前代码执行的线程
* 4.getName():获取当前线程的名字
* 5.setName(String name):设置当前线程的名字
* 6.yield():释放当时CPU的执行权
* 7.join():在线程a中调用线程b的join方法,则线程a进入阻塞状态,直到线程b完全执行完以后,线程a才结束阻塞状态
* 8.stop():强制当前进程结束
* 9.sleep(millis):当前进程停下
* 10.isAlive():判断当前线程是否存活
*
*
*
* 线程的优先级:
* 1.
* MAX_PRIORITY:10
* MIN_PRIORITY:1
* NORM_PRIORITY:5
* 2.如何来获取or设置当前线程的优先级?
* getPriority();//获取
* setPriority(int priority);//设置
* 说明:高优先级的线程会抢占低优先级CPU的执行权,但是只是从概率上而言,并不意味着只有当
* 高优先级的线程执行完之后低优先级的线程才能被执行
* @author Baobao
* @create 2021-07-31 11:15
*/
class HelloThread extends Thread{
@Override
public void run() {
for (int i = 0; i < 100; i++) {
if(i%2==0){
// try {
// sleep(10);//单位是毫秒
// } catch (InterruptedException e) {
// e.printStackTrace();
// }
System.out.println(Thread.currentThread().getName()+":"+Thread.currentThread().getPriority()+":"+i);
}
if(i%20==0){
this.yield();
}
}
}
public HelloThread(String name){
super(name);
}
}
public class ThreadMethodTest {
public static void main(String[] args) {
HelloThread h1=new HelloThread("Thread:1");
// h1.setName("线程1");
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());
}
}
package java1;
/**
*
* 创建3个窗口买票,总票数为100张
*
*
*
* @author Baobao
* @create 2021-08-01 17:17
*/
class Window extends Thread{
private static int ticket=100;
@Override
public void run() {
while(true){
if(ticket>0){
System.out.println(getName()+":卖票,票号为:"+ticket);
ticket--;
}else{
break;
}
}
}
}
public class WindowTest {
public static void main(String[] args) {
Window w1=new Window();
Window w2=new Window();
Window w3=new Window();
w1.setName("窗口1");
w2.setName("窗口2");
w3.setName("窗口3");
w1.start();
w2.start();
w3.start();
}
}
package java1;
/**
* 实现Runnable接口的方式
* @author Baobao
* @create 2021-08-01 17:44
*/
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 w1=new Window1();
Thread t1 = new Thread(w1);
Thread t2 = new Thread(w1);
Thread t3 = new Thread(w1);
t1.setName("窗口1");
t2.setName("窗口2");
t3.setName("窗口3");
t1.start();
t2.start();
t3.start();
}
}
package java1;
/**
*
* 创建多线程的方式2:
* 实现Runnable接口的方式
* 1.创建一个实现了Runnable接口的类
* 2.实现Runnable中的抽象方法(run方法)
* 3.创建实现类的对象
* 4.将此对象作为参数传到Thread类的构造器中,创建Thread类的对象
* 5.通过Thread类的对象去调用start方法
*
*
*
* 比较创建线程的两种方式:
* 开发中:优先选择实现Runnable接口的方式
* 原因:1.没有单继承性的局限性
* 2.实现的方式更适合来处理多个线程有共享数据的情况
* 联系:Thread类本身也实现了Runnable接口,两种方式都需要重写run方法,将线程要执行的逻辑声明在run方法中
*
* @author Baobao
* @create 2021-08-01 17:31
*/
class MThread implements Runnable{
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println(i);
}
}
}
public class ThreadTest1 {
public static void main(String[] args) {
MThread mThread = new MThread();
Thread t1=new Thread(mThread);
t1.start();
}
}