idea线程，简单了解一下_随笔

idea线程，简单了解一下

1.什么是线程

2.为什么需要线程

3.Java中是如何实现多线程的？

第一种：通过继承Thread类。

第二种：通过继承RunThread类

4.线程中常见的方法

4.1 sleep方法：模拟网络延迟

4.2 yield：当前线程主动放弃时间片，回到就绪状态，竞争下一次时间片

4.3 join：允许其他线程加入到当前线程中

5. sewPriority

6.setDaemon(true)

1.什么是线程

想要知道什么是线程，就要先了解一下进程。

1.1 什么是进程。

正在运行的程序。系统分配资源的基本单位。如果是单核cpu，宏观上进程是并行运行，微观上串行运行的。

1.2什么是线程

        线程，又称轻量级进程（Light Weight Process）。
        进程中的一条执行路径，也是CPU的基本调度单位。
        一个进程由一个或多个线程组成，彼此间完成不同的工作，
        同时执行，称为多线程。

2.为什么需要线程

为了提高cpu的效率（使用率）。

3.Java中是如何实现多线程的？第一种：通过继承Thread类。

public class TestRunnable02 {
    public static void main(String[] args) {
        //3.创建线程对象
        MyThread2 my=new MyThread2();
        //4.启动线程---自动run方法
        my.start();

        //main方法
        for (int i = 0; i < 20; i++) {
            System.out.println("main+++++++++"+i);
        }
    }

}
//1.创建类并继承Thread类
class MyThread2 extends Thread{
    //2.重写run方法，线程执行的任务代码
    @Override
    public void run() {
        for (int i = 0; i <20; i++) {
            //Thread.currentThread().getName() 任意使用
            System.out.println(Thread.currentThread().getName()+"!!!!!!!!!!!!!!!!"+i);
        }
    }
}

结果：

第二种：通过继承RunThread类

public class TestRunable {
    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();

        Thread thread = new Thread(myRunnable,"线程A");
        Thread thread1 = new Thread(myRunnable,"线程B");

        thread.start();
        thread1.start();
    }
}
class MyRunnable implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println(Thread.currentThread().getName()+"~~~~~~~~~~~~~~"+i);
        }
    }
}

结果：

例子：存钱取钱

public class TestBank {
    public static void main(String[] args) {
        Bank bank = new Bank("123321",0);

        //创建一个存钱任务
        withdrawMoney withdrawMoney = new withdrawMoney(bank);

        //创建一个取钱任务
        saveMoney saveMoney = new saveMoney(bank);

        Thread t1 = new Thread(withdrawMoney,"晨晨");
        Thread t2 = new Thread(saveMoney,"冰冰");

        t1.start();
        t2.start();

    }
}
//yhk类
class Bank{
    private String BankNo;//卡号
    private double balance;//余额

    public Bank(String bankNo, double balance) {
        BankNo = bankNo;
        this.balance = balance;
    }

    public String getBankNo() {
        return BankNo;
    }

    public double getBalance() {
        return balance;
    }

    public void setBankNo(String bankNo) {
        BankNo = bankNo;
    }

    public void setBalance(double balance) {
        this.balance = balance;
    }
}

//取钱
class saveMoney implements Runnable{
    private Bank bank;
    public saveMoney(Bank bank){
        this.bank=bank;
    }
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            if (bank.getBalance()<1000){
                System.out.println("卡中余额不足，请赶紧充值......");
                i--;
            }else {
                bank.setBalance(bank.getBalance()-1000);
                System.out.println(Thread.currentThread().getName()+"向卡号为:"+bank.getBankNo()+"取出了1000，余额为:"+bank.getBalance());
            }
         }
    }
}

//存钱
class withdrawMoney implements Runnable{
    private Bank bank;
    public withdrawMoney(Bank bank){
        this.bank=bank;
    }
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
             bank.setBalance(bank.getBalance()+1000);
            System.out.println(Thread.currentThread().getName()+"向卡号为:"+bank.getBankNo()+"存入了1000，余额为"+bank.getBalance());
        }
    }
}

总结：通过该例子每个线程可以执行不同的任务。

4.线程中常见的方法 4.1 sleep方法：模拟网络延迟

public class TestSleep {
    public static void main(String[] args) {
        MySleep mySleep=new MySleep();

        Thread t1=new Thread(mySleep,"线程A");
        t1.start();
        for (int i = 0; i < 10; i++) {
            System.out.println("main======="+i);
        }
    }

}
class MySleep implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            try {
                Thread.sleep(200);//模拟网路延迟0.2秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"========="+i);
        }
    }
}

4.2 yield：当前线程主动放弃时间片，回到就绪状态，竞争下一次时间片

public class TestYiled {
    public static void main(String[] args) {
        MyYiled myYiled = new MyYiled();
        MyYiled myYiled1 = new MyYiled();

        myYiled.start();
        myYiled1.start();


    }
}
class MyYiled extends Thread{

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            Thread.yield();
            System.out.println(Thread.currentThread().getName()+"========="+i);
        }
    }
}

4.3 join：允许其他线程加入到当前线程中

public class MyJoin {
    public static void main(String[] args) throws Exception {
        MyJoins j1 = new MyJoins();
        MyJoins j2 = new MyJoins();
        j1.start();
        j2.start();

        j1.join();//表示j1线程加入当前main线程中，main线程需要等t1线程完毕后才能执行。
        j2.join();

        for (int i = 0; i < 10; i++) {
            System.out.println("main==="+i);
        }
    }
}
class MyJoins extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+"====="+i);
        }
    }
}

5. sewPriority

package com.qy.Thread;


public class MySetPriority {
    public static void main(String[] args) {
        MyPriority m = new MyPriority();

        Thread t1 = new Thread(m,"线程A");
        Thread t2 = new Thread(m,"线程B");
        Thread t3 = new Thread(m,"线程C"); //t3优先级最大 它获取cpu的概率更高
        t1.setPriority(1);
        t2.setPriority(5);
        t3.setPriority(10);
        t1.start();
        t2.start();
        t3.start();
    }
}
class MyPriority implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println(Thread.currentThread().getName()+"======="+i);
        }
    }
}

6.setDaemon(true)

守护线程:
     线程对象.setDaemon(true);设置为守护线程。
     线程有两类:用户线程（前台线程）和守护线程（后台线程）
     如果程序中所有前台线程都执行完毕了，后台线程也会自动结束。
     垃圾回收线程属于守护线程。

package com.qy.Thread;


public class MysetDaemon {
    public static void main(String[] args) {
        My my = new My();
        My01 my01 = new My01();
        my.setDaemon(true);//设置my为守护线程，当主线程结束，那么my线程也会结束
        my.start();
        my01.start();

        for (int i = 0; i < 20; i++) {
            System.out.println("main===="+i);
        }
    }
}
class My extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println(Thread.currentThread().getName()+"====="+i);
            try {
                Thread.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
class My01 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println(Thread.currentThread().getName()+"====="+i);
        }
    }
}

欢迎分享，转载请注明来源：内存溢出

原文地址: http://outofmemory.cn/zaji/5697036.html

idea线程，简单了解一下

发表评论

评论列表（0条）