Java实例——线程

最新推荐文章于 2024-07-08 10:57:58 发布
最新推荐文章于 2024-07-08 10:57:58 发布
阅读量659 收藏
点赞数
分类专栏： Java 文章标签： java jvm 面试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Zain_horse/article/details/129173088
版权

1、查看线程存活状态
Thread.isAlive()
Thread.getName()

public class MyThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            printMsg();
        }
    }

    public static void printMsg(){
        Thread thread = Thread.currentThread();
        //Thread.getName()	获取线程名称
        System.out.println("name=["+thread.getName()+"]");
    }

    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.setName("MyThread");	//修改线程名称
        System.out.println("before start()，the Thread Alive = " + myThread.isAlive());//判断线程存活状态
        myThread.start();
        System.out.println("just after start()，the Thread Alive = " + myThread.isAlive());
        for (int i = 0; i < 10; i++) {
            printMsg();
        }
        System.out.println("the end of Thread Alive = " + myThread.isAlive());
    }
}

输出结果

before start()，the Thread Alive = false
just after start()，the Thread Alive = true
name=[main]
name=[main]
name=[main]
name=[main]
name=[MyThread]
name=[main]
name=[main]
name=[main]
name=[main]
name=[main]
name=[main]
name=[MyThread]
the end of Thread Alive = true
name=[MyThread]
name=[MyThread]
name=[MyThread]
name=[MyThread]
name=[MyThread]
name=[MyThread]
name=[MyThread]
name=[MyThread]

2、多线程同步锁
有三种同步锁：synchronize锁，lock锁，volatile锁

  1. synchronize锁是一般情况下Java多线程开发所使用的最常用同步锁。
  2. lock锁同样是常见同步锁。
  3. volatile锁是一种轻量同步锁，能够减轻同步锁所带来的的资源消耗，但只能所用在变量上。

lock锁与synchronize锁的区别:

  1. 两者都是可重入锁，自己可以再次获取自己的内部锁。
  2. synchronized是依赖于虚拟机的，而Lock锁依赖JDK。
  3. synchronized锁可以自动释放锁，而Lock锁必须要手动释放锁。
  4. synchronized锁的两个线程1和线程2，如果当前线程1获得锁，线程2等待，如果线程1阻塞，线程2会一致等待下去，而Lock锁不一定会等下去，如果尝试获几次取不到锁，线程2可以不用一直等待就结束了。

synchronize锁的使用场景：卖票

class MyThread extends Thread{
    public static void main(String[] args) {
        Ticket ticket=new Ticket();
        Thread thread = new Thread(ticket,"售票员小张");
        thread.start();

        Thread thread1 = new Thread(ticket,"售票员小刘");
        thread1.start();
    }
}
//票务系统
class Ticket implements Runnable {
    //总票数
    private int ticketCount = 40;
    
    @Override
    public void run() {
        while (true) {
        	//对票务类进行同步锁，避免线程产生脏数据
            synchronized (Ticket.class) {
                if (ticketCount > 0) {
                    try {
                        //小张在出票的时候被领导叫走了
                        //这个时候呢，小刘也要卖这张票
                        //线程睡眠是在模拟网络延迟的情况
                        Thread.sleep(100);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "正在售票,剩余" + (--ticketCount));
                }
            }
        }
    }
}

输出结果

售票员小张正在售票,剩余39
售票员小张正在售票,剩余38
售票员小张正在售票,剩余37
售票员小张正在售票,剩余36
售票员小刘正在售票,剩余35
售票员小刘正在售票,剩余34
售票员小刘正在售票,剩余33
售票员小刘正在售票,剩余32
售票员小刘正在售票,剩余31
售票员小刘正在售票,剩余30
售票员小刘正在售票,剩余29
售票员小刘正在售票,剩余28
售票员小刘正在售票,剩余27
售票员小刘正在售票,剩余26
售票员小刘正在售票,剩余25
售票员小刘正在售票,剩余24
售票员小刘正在售票,剩余23
售票员小刘正在售票,剩余22
售票员小刘正在售票,剩余21
售票员小刘正在售票,剩余20
售票员小张正在售票,剩余19
售票员小张正在售票,剩余18
售票员小刘正在售票,剩余17
售票员小刘正在售票,剩余16
售票员小刘正在售票,剩余15
售票员小刘正在售票,剩余14
售票员小刘正在售票,剩余13
售票员小刘正在售票,剩余12
售票员小刘正在售票,剩余11
售票员小刘正在售票,剩余10
售票员小刘正在售票,剩余9
售票员小刘正在售票,剩余8
售票员小刘正在售票,剩余7
售票员小刘正在售票,剩余6
售票员小刘正在售票,剩余5
售票员小刘正在售票,剩余4
售票员小刘正在售票,剩余3
售票员小刘正在售票,剩余2
售票员小张正在售票,剩余1
售票员小刘正在售票,剩余0

Lock锁使用场景：卖票

class MyThread extends Thread{
    public static void main(String[] args) {
        //创建锁对象
        Lock lock=new ReentrantLock();
        //创建要执行的任务
        Ticket ticket=new Ticket(lock);

        //创建线程并开启线程
        Thread t1=new Thread(ticket,"售票员张小飞");
        t1.start();

        Thread t2=new Thread(ticket,"售票员关小羽");
        t2.start();
    }
}

class Ticket implements Runnable {
    private Lock lock;
    private int count = 40;

    public Ticket(Lock lock) {
        this.lock = lock;
    }
    
    @Override
    public void run() {
        while (true) {
            //使用lock锁进行加锁
            lock.lock();
            if (count > 0) {
                try {
                    Thread.sleep(100);
                    System.out.println(Thread.currentThread().getName() + "售出一张票，剩余" + (--count) + "张");
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                }
            }else{
                System.out.println("售票结束");
                System.exit(0);
            }
    }
}

输出结果

售票员张小飞售出一张票，剩余39张
售票员张小飞售出一张票，剩余38张
售票员张小飞售出一张票，剩余37张
售票员张小飞售出一张票，剩余36张
售票员张小飞售出一张票，剩余35张
售票员张小飞售出一张票，剩余34张
售票员张小飞售出一张票，剩余33张
售票员张小飞售出一张票，剩余32张
售票员张小飞售出一张票，剩余31张
售票员张小飞售出一张票，剩余30张
售票员张小飞售出一张票，剩余29张
售票员张小飞售出一张票，剩余28张
售票员张小飞售出一张票，剩余27张
售票员张小飞售出一张票，剩余26张
售票员张小飞售出一张票，剩余25张
售票员张小飞售出一张票，剩余24张
售票员张小飞售出一张票，剩余23张
售票员张小飞售出一张票，剩余22张
售票员张小飞售出一张票，剩余21张
售票员张小飞售出一张票，剩余20张
售票员张小飞售出一张票，剩余19张
售票员张小飞售出一张票，剩余18张
售票员张小飞售出一张票，剩余17张
售票员张小飞售出一张票，剩余16张
售票员张小飞售出一张票，剩余15张
售票员张小飞售出一张票，剩余14张
售票员张小飞售出一张票，剩余13张
售票员张小飞售出一张票，剩余12张
售票员张小飞售出一张票，剩余11张
售票员张小飞售出一张票，剩余10张
售票员张小飞售出一张票，剩余9张
售票员张小飞售出一张票，剩余8张
售票员张小飞售出一张票，剩余7张
售票员张小飞售出一张票，剩余6张
售票员张小飞售出一张票，剩余5张
售票员张小飞售出一张票，剩余4张
售票员张小飞售出一张票，剩余3张
售票员张小飞售出一张票，剩余2张
售票员张小飞售出一张票，剩余1张
售票员张小飞售出一张票，剩余0张
售票结束

我们可以看到使用Lock锁之后，另一线程无法调用run方法，一直处于等待，在尝试运行run()方法几次之后，结束了另一进程。

3、线程优先级
setPriority(int priority)

class MyThread extends Thread{
    private int countDown = 5;
    private volatile double d = 0;  //同步变量d

    public MyThread(int priority) {
        setPriority(priority);  //设置当前线程优先级
        start();    //开启当前线程
    }

    @Override
    public String toString() {
        return super.toString() + ":" + countDown;
    }

    @Override
    public void run() {
        synchronized(this){
            while (true){
                for (int i = 0; i < 5000; i++) {
                    d = d + (Math.PI + Math.E) / i;
                    System.out.println(this);
                    if (--countDown == 0) return;
                }
            }
        }
    }

    public static void main(String[] args) {
        new MyThread(Thread.MAX_PRIORITY);
        for (int i = 1; i < 5; i++)
            new MyThread(Thread.MIN_PRIORITY);
    }
}

输出结果

Thread[Thread-0,10,main]:5
Thread[Thread-1,1,main]:5
Thread[Thread-2,1,main]:5
Thread[Thread-3,1,main]:5
Thread[Thread-1,1,main]:4
Thread[Thread-0,10,main]:4
Thread[Thread-1,1,main]:3
Thread[Thread-3,1,main]:4
Thread[Thread-4,1,main]:5
Thread[Thread-2,1,main]:4
Thread[Thread-4,1,main]:4
Thread[Thread-3,1,main]:3
Thread[Thread-1,1,main]:2
Thread[Thread-0,10,main]:3
Thread[Thread-1,1,main]:1
Thread[Thread-3,1,main]:2
Thread[Thread-4,1,main]:3
Thread[Thread-2,1,main]:3
Thread[Thread-4,1,main]:2
Thread[Thread-3,1,main]:1
Thread[Thread-0,10,main]:2
Thread[Thread-4,1,main]:1
Thread[Thread-2,1,main]:2
Thread[Thread-0,10,main]:1
Thread[Thread-2,1,main]:1

4、死锁问题及解决方案

  • 死锁的情形： 多个线程同时被阻塞，它们中的一个或者全部都在等待某个资源被释放。由于线程被无限期地阻塞，因此程序不可能正常终止。
  • 死锁产生必要条件：
    1. 互斥使用，即当资源被一个线程使用(占有)时，别的线程不能使用。
    2. 不可抢占，资源请求者不能强制从资源占有者手中夺取资源，资源只能由资源占有者主动释放。
    3. 请求和保持，即当资源请求者在请求其他的资源的同时保持对原有资源的占有。
    4. 循环等待，即存在一个等待队列：P1占有P2的资源，P2占有P3的资源，P3占有P1的资源。这样就形成了一个等待环路。
  • 解决死锁方案
    一种是synchronized同步锁，另一种是Lock显式锁
    为避免死锁，采用信号量控制多线程程序，Semaphore类是用来创建信号量对象的

使用Semaphore控制多线程

public class UnLockTest {
    public static String obj1 = "obj1";
    public static final Semaphore a1 = new Semaphore(1);	//设置a1信号量为1
    public static String obj2 = "obj2";
    public static final Semaphore a2 = new Semaphore(1);	//设置a2信号量为1

    public static void main(String[] args) {
        LockAa la = new LockAa();
        new Thread(la).start();
        LockBb lb = new LockBb();
        new Thread(lb).start();
    }
}
class LockAa implements Runnable {
    public void run() {
        try {
            System.out.println(new Date().toString() + " LockA 开始执行");
            while (true) {
            	//tryAcquire(1, TimeUnit.SECONDS) 1秒尝试请求获取线程许可，TimeUnit.SECONDS 获取秒数
                if (UnLockTest.a1.tryAcquire(1, TimeUnit.SECONDS)) {
                    System.out.println(new Date().toString() + " LockA 锁住 obj1");
                    //尝试获取a1线程后，尝试获取a2线程
                    if (UnLockTest.a2.tryAcquire(1, TimeUnit.SECONDS)) {
                        System.out.println(new Date().toString() + " LockA 锁住 obj2");
                        Thread.sleep(60 * 1000); // do something
                    }else{
                        System.out.println(new Date().toString() + "LockA 锁 obj2 失败");
                    }
                }else{
                    System.out.println(new Date().toString() + "LockA 锁 obj1 失败");
                }
                UnLockTest.a1.release(); // 释放a1信号量
                UnLockTest.a2.release(); //	释放a2信号量
                Thread.sleep(1000); // 马上进行尝试，现实情况下do something是不确定的
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
class LockBb implements Runnable {
    public void run() {
        try {
            System.out.println(new Date().toString() + " LockB 开始执行");
            while (true) {
                if (UnLockTest.a2.tryAcquire(1, TimeUnit.SECONDS)) {
                    System.out.println(new Date().toString() + " LockB 锁住 obj2");
                    if (UnLockTest.a1.tryAcquire(1, TimeUnit.SECONDS)) {
                        System.out.println(new Date().toString() + " LockB 锁住 obj1");
                        Thread.sleep(60 * 1000); // do something
                    }else{
                        System.out.println(new Date().toString() + "LockB 锁 obj1 失败");
                    }
                }else{
                    System.out.println(new Date().toString() + "LockB 锁 obj2 失败");
                }
                UnLockTest.a1.release();
                UnLockTest.a2.release();
                Thread.sleep(10 * 1000);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

输出结果

Thu Feb 23 02:55:40 CST 2023 LockB 开始执行
Thu Feb 23 02:55:40 CST 2023 LockA 开始执行
Thu Feb 23 02:55:40 CST 2023 LockA 锁住 obj1
Thu Feb 23 02:55:40 CST 2023 LockB 锁住 obj2
Thu Feb 23 02:55:41 CST 2023LockB 锁 obj1 失败
Thu Feb 23 02:55:41 CST 2023LockA 锁 obj2 失败
Thu Feb 23 02:55:42 CST 2023 LockA 锁住 obj1
Thu Feb 23 02:55:42 CST 2023 LockA 锁住 obj2
Thu Feb 23 02:55:51 CST 2023 LockB 锁住 obj2
Thu Feb 23 02:55:51 CST 2023 LockB 锁住 obj1

使用信号量控制多线程锁的步骤
步骤一：创建Semaphore对象

public static String obj1 = "obj1";
public static String obj2 = "obj2";
public static final Semaphore a1 = new Semaphore(1);	//设置1个资源数量
public static final Semaphore a2 = new Semaphore(1);	//设置1个资源数量

步骤二：显式Lock创建

Lock lock1 = new Lock();
Lock lock2 = new Lock();

步骤三：创建线程

new Thread(lock1).start();
new Thread(lock2).start();

步骤四：线程类创建

class ThreadA implements Runnable{
	public void run() throws Exception{
		while(true){
			if(UnLockTest.a1.tryAcquire(1,TimeUnit.SECONDS)){
				System.out.println(new Date().toString() + " lock1 锁住 obj1");
				if(UnLockTest.a2.tryAcquire(1,TimeUnit.SECONDS)){
					System.out.println(new Date().toString() + " lock1 锁住 obj2");
					Thread.sleep(60*1000);
				}
			}else{
               System.out.println(new Date().toString() + "lock1 锁 obj1 失败");
            }
            UnLockTest.a1.release(); // 释放a1信号
            UnLockTest.a2.release();	//释放a2信号
            Thread.sleep(1000); // 空出信号量为ThreadB锁对象obj1,obj2    
		}
	}
}
class ThreadB implements Runnable{
	public void run() throws Exception{
		while(true){
			if(UnLockTest.a1.tryAcquire(1,TimeUnit.SECONDS)){
				System.out.println(new Date().toString() + " lock2 锁住 obj1");
				if(UnLockTest.a2.tryAcquire(1,TimeUnit.SECONDS)){
					System.out.println(new Date().toString() + " lock2 锁住 obj2");
					Thread.sleep(60*1000);
				}
			}else{
               System.out.println(new Date().toString() + "lock2 锁 obj1 失败");
            }
            UnLockTest.a1.release(); //释放a1信号
            UnLockTest.a2.release(); //释放a2信号
            Thread.sleep(1000); // 空出信号量为ThreadA锁对象obj1,obj2    
		}
	}
}

输出结果

Thu Feb 23 03:41:41 CST 2023 LockA 开始执行
Thu Feb 23 03:41:41 CST 2023 LockB 开始执行
Thu Feb 23 03:41:41 CST 2023 LockA 锁住 obj1
Thu Feb 23 03:41:41 CST 2023 LockB 锁住 obj2
Thu Feb 23 03:41:42 CST 2023LockB 锁 obj1 失败
Thu Feb 23 03:41:42 CST 2023LockA 锁 obj2 失败
Thu Feb 23 03:41:43 CST 2023 LockA 锁住 obj1
Thu Feb 23 03:41:43 CST 2023 LockA 锁住 obj2
Thu Feb 23 03:41:52 CST 2023 LockB 锁住 obj2
Thu Feb 23 03:41:52 CST 2023 LockB 锁住 obj1

5、获取线程ID
获取线程ID的方式：getId()，自定义编程ID

public class Main extends Object implements Runnable {
    private ThreadID var;

    public Main(ThreadID v) {
        this.var = v;
    }

    public void run() {
        try {
            print("var getThreadID =" + var.getThreadID());
            Thread.sleep(2000);
            print("var getThreadID =" + var.getThreadID());
        } catch (InterruptedException x) {
        }
    }

    private static void print(String msg) {
        String name = Thread.currentThread().getName();
        System.out.println(name + ": " + msg);
    }

    public static void main(String[] args) {
        ThreadID tid = new ThreadID();
        Main shared = new Main(tid);

        try {
            Thread threadA = new Thread(shared, "threadA");
            threadA.start();

            Thread.sleep(500);

            Thread threadB = new Thread(shared, "threadB");
            threadB.start();

            Thread.sleep(500);

            Thread threadC = new Thread(shared, "threadC");
            threadC.start();
        } catch (InterruptedException x) {
        }
    }
}

//继承ThreadLocal类，是本地线程变量
class ThreadID extends ThreadLocal {
    private int nextID;	//线程ID变量
    public ThreadID() {
        nextID = 10001;	//初始化线程ID
    }
    //同步操作线程ID
    private synchronized Integer getNewID() {
        Integer id = new Integer(nextID);
        nextID++;
        return id;
    }
    
    protected Object initialValue() {
        print("in initialValue()");
        return getNewID();
    }

    public int getThreadID() {
        Integer id = (Integer) get();
        return id.intValue();
    }

    private static void print(String msg) {
        String name = Thread.currentThread().getName();
        System.out.println(name + ": " + msg);
    }
}

输出结果

threadA: in initialValue()
threadA: var getThreadID =10001
threadB: in initialValue()
threadB: var getThreadID =10002
threadC: in initialValue()
threadC: var getThreadID =10003
threadA: var getThreadID =10001
threadB: var getThreadID =10002
threadC: var getThreadID =10003

6、线程挂起
Thread.join() 进入挂起状态，即等待激活状态

public class SleepingThread extends Thread {
    private int countDown = 5;
    private static int threadCount = 0;
    public SleepingThread() {
        super("" + ++threadCount);
        start();
    }

    public String toString() {
        return "#" + getName() + ": " + countDown;
    }

    public void run() {
        while (true) {
            System.out.println(this);
            if (--countDown == 0)
                return;
            try {
                sleep(100);
            }
            catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }

    public static void main(String[] args)throws InterruptedException {
        for (int i = 0; i < 5; i++)
            new SleepingThread().join();
        System.out.println("线程已被挂起");
    }
}

输出结果

#1: 5
#1: 4
#1: 3
#1: 2
#1: 1
#2: 5
#2: 4
#2: 3
#2: 2
#2: 1
#3: 5
#3: 4
#3: 3
#3: 2
#3: 1
#4: 5
#4: 4
#4: 3
#4: 2
#4: 1
#5: 5
#5: 4
#5: 3
#5: 2
#5: 1
线程已被挂起

7、终止进程
interrupt() ##终止进程
isInterrupt() ##判断是否为终止进程

public class MyThread extends Thread {
    @Override
    public void run() {
        try {
            sleep(5000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }

    public static void main(String[] args) throws IOException, InterruptedException {
        Thread thread = new MyThread();
        thread.start();
        System.out.println(new Date());
        System.out.println("50秒之内按任意键中断线程");
        System.in.read();
        thread.interrupt(); //提前终止程序
        thread.join();  //挂起程序
        System.out.println("程序已退出");
        System.out.println(new Date());
    }
}

输出结果

Thu Feb 23 04:27:01 CST 2023
50秒之内按任意键中断线程
 
程序已退出
Thu Feb 23 04:27:02 CST 2023

8、生产者/消费者问题
需要的是什么？
1、共享存储空间 content

class CubbyHole{
	private int contents;	//空间存储量
	private boolean available = false;	//是否可用
	//获取
	public synchronized int get(){
		while(available == false){
			try{
				wait();
			}catch(Exception e){}
		}
		available = false;
		notifyAll();
		return contents;
	}
	public synchronized void put(int value){
		while(available == true){
			try{
				wait();
			}catch(Exception e){}
		}
		contents = values;
		available = true;
		notifyAll();
	}
}

2、生产者线程 producter

class Consumer extends Thread{
	private CubbyHole cubbyhole;
	private int number;
	public Consumer(CubbyHole c,int number){
		cubbyhole = c;
		this.number = number;
	}
	public void run(){
		int value = 0;
		for(int i = 0;i<10;i++){
			value = cubbyhole.get();
			System.out.println("消费者 #" + this.number+ " got: " + value);
		}
	}
}

3、消费者线程 consumer

public Producer extends Thread{
	private CubbyHole cubbyhole;
	private int number;
	public Producer(CubbyHole c,int number){
		cubbyhole = c;
		this.number = number;
	}
	
	public void run(){
		for(int i = 0; i < 10 ; i++){
			cubbyhole.put(i);
			System.out.println("生产者 #" + this.number + " put: " + i);
	        try {
	            sleep((int)(Math.random() * 100));
	        } catch (InterruptedException e) { }
		}
	}
}

输出结果

消费者 #1 got: 0
生产者 #1 put: 0
生产者 #1 put: 1
消费者 #1 got: 1
生产者 #1 put: 2
消费者 #1 got: 2
生产者 #1 put: 3
消费者 #1 got: 3
生产者 #1 put: 4
消费者 #1 got: 4
生产者 #1 put: 5
消费者 #1 got: 5
生产者 #1 put: 6
消费者 #1 got: 6
生产者 #1 put: 7
消费者 #1 got: 7
生产者 #1 put: 8
消费者 #1 got: 8
生产者 #1 put: 9
消费者 #1 got: 9
Zain_horse
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
27、JAVA进阶——线程同步和线程间的通信
不迁怒，不贰过。小知识，大智慧。
10-11 1027
一、线程同步的必要性 二、实现线程同步 1. 同步方法 2. 同步代码块 3. 死锁 三、线程间通信的必要性 四、实现线程间通信
Java基础【重点】多线程————线程安全问题
m0_72786443的博客
09-19 256
java 多线程 线程安全问题
java多线程示例
03-02
Java中的多线程有三种实现方式： 1.继承Thread类，重写run方法。Thread本质上也是一个实现了Runnable的实例，他代表一个线程的实例，并且启动线程的唯一方法就是通过Thread类的start方法。 2.实现Runnable接口，并实现该接口的run()方法.创建一个Thread对象，用实现的Runnable接口的对象作为参数实例化Thread对象，调用此对象的start方法。 本示例演示和wait和sleep、线程锁的使用。
线程java代码实例[7个例子]
White
07-23 4537
1 线程创建 1）继承Thread类方式 代码： package com.whl.thread; /** * 注: * java.lang包中放着java最核心最基础的类、接口：Object、System、Thread、Runnable * Thread.currentThread()获取当前cpu执行线程 */ public class TestThread { public static void main(String[] args) { /** *
Java中多线程经典案例
最新发布
2301_79288225的博客
07-08 745
相反懒汉模式则会引起线程不安全,因为懒汉模式是在有需要的时候才会去实例化对象,在多线程编程中懒汉模式要进行读和写操作,这一修改变量的值不是原子的,所有会造成线程不安全的问题,因此我们要使用synchronized对读和写操作进行加锁,打包成一个原子的操作,加锁会影响性能的问题,如果是第一次判断instance是否为空则需要加锁,若后续第二次...等,每次加锁都势必会影响性能问题,因此我们可以考虑在加一个if判断。
java多线程示例_Java线程示例
从零开始的教程世界
07-17 239
java多线程示例Welcome to the Java Thread Example. Process and Thread are two basic units of execution. Concurrency programming is more concerned with java threads. 欢迎使用Java线程示例。 进程和线程是执行的两个基本单元。 并发编程更关注Jav...
Java 线程简单示例
啸铁
09-25 381
Java 线程可以通过 extends Thread 类来实现，也可以 implements Runnable 接口来实现。 示例 下面的例子分别给出了通过 extends Thread 和 implements Runnable 来实现线程的例子。可以看出，无论哪种方法，都要实现 public static void run() 方法，调用时先 new Runner() 或 new ExtendsThread，然后将 new 出的对象传入Thread(), 构造一个 Thread 对象, 调用 Threa
Java——线程案例
凌风暨
10-04 919
/* 实现两个人同时show需要使用多线程 创建线程的第一种方式： 1、创建一个类继承Thread 2、重写Thread类中的run方法 创建线程是为了执行任务 任务代码必须有存储位置，run方法就是任务代码的存储位置 3、创建子类对象，其实就是在创建线程 4、启动线程 主线程的任务代码在main函数中 子线程的任务代码在Thread类的
Java多线程——线程八锁案例分析.docx
06-21
在Java多线程编程中，线程安全是一个关键概念，特别是在并发访问共享资源时。"线程八锁案例分析"文档中的示例着重展示了`synchronized`关键字如何在控制线程同步方面发挥作用。以下是对这些案例的详细分析： 案例1...
Java基础——多线程
qq_45821255的博客
04-14 478
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 Java基础——多线程前言一、线程概述1.什么是进程和线程？2.什么是并行和并发？二、多线程的实现1.继承Thread实现多线程2.Runnable接口实现多线程3.总结 前言 提示：这里可以添加本文要记录的大概内容： 一、线程概述 1.什么是进程和线程？ 进程是指一个内存中的运行程序。每个进程都有一块自己独立的内存空间，一个进程中可以启动一个或多个线程。 线程是指进程中的一个执行流程，线程是由进程创建的，它是进程的一个实体。一个进.
java实例——闹钟——看看吧 总有思路的
04-25
总的来说，通过这个“java实例——闹钟”，我们可以深入了解Java的定时器机制，这对于开发各种需要定时触发功能的应用（如定时备份、自动检查更新等）非常有用。不断练习和理解这些基础知识，将有助于提升你在Java...
java 线程池示例（自己实现的参考别人的代码）
04-10
NULL 博文链接：https://yulincqupt.iteye.com/blog/1673919
java线程实例 各种小Demo
04-24
java中各种类型的线程实例,小Demo
java 多线程示例
08-17
一个很完整的例子来介绍java的多线程，对初学者有不错的借鉴意义
java 线程的例子_java多线程例子
weixin_42374582的博客
02-25 148
到这里我们做一个完整的例子来说明线程产生的方式不同而生成的线程的区别：package debug;import java.io.*;import java.lang.Thread;class MyThread extends Thread{public int x = 0;public void run(){System.out.println(++x);}}class R implements ...
java多线程示例_java多线程示例
weixin_28943105的博客
02-16 815
/*进程：一个正在运行的程序。每一个进程都有一个执行顺序，该顺序就是执行路径，或者叫执行单元线程：就是进程中的一个执行单元。线程控制着进程。一个进程中至少有一个线程。多线程示例。创建多线程有两种方法。一种继承Thread类，并且覆盖Thread中的run方法，并且调用其start方法。startt方法的作用是开启线程，并且调用run方法。复写run方法的目的是：将自定义的代码存储在run方法中，让...
Java多线程应用实例
热门推荐
void
08-23 1万+
Java多线程及其应用实例，数据库连接池，线程池
java多线程实例代码_java多线程的代码示例
weixin_33631305的博客
02-20 274
本篇文章给大家带来的内容是关于java多线程的代码示例，有一定的参考价值，有需要的朋友可以参考一下，希望对你有所帮助。1：ExecutorService executor = new ThreadPoolExecutor(5, 5, 60, TimeUnit.SECONDS, new LinkedBlockingQueue());list.forEach(a -> {executor.sub...
Java：多线程实例
qq_43220266的博客
01-09 303
通过Thread类实现多线程 Thread的run()方法为普通方法。 Thread的start()的方法可以启动多线程 另外介绍几个常用的操作方法 ①线程休眠(sleep方法)：指的是让线程暂缓执行一下，让线程进入阻塞状态，等到了预计时间之后再恢复执行 线程休眠会交出CPU，让CPU去执行其他的任务。sleep方法不会释放锁。 ②线程让步(yield()方法)：是调用yield方法会让当前线程交...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Zain_horse

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值