线程thread使用

最新推荐文章于 2024-07-17 23:30:09 发布
原创 最新推荐文章于 2024-07-17 23:30:09 发布 · 292 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#线程

本文深入探讨了Java中的多种并发编程技术，包括使用volatile关键字、原子变量、显式锁、信号量、闭锁、栅栏等高级并发工具进行线程同步的方法。通过具体的代码示例，详细解释了这些工具如何帮助解决并发编程中的常见问题，如死锁、竞争条件和资源争用。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

MyRun

package com.lv;

/**
 * Created by LocalUser on 2018/4/24.
 */
public class MyRun implements Runnable{

    private volatile boolean on = true;
    private int i = 0;
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getId() + "线程执行中");

        while (on && !Thread.currentThread().isInterrupted()){
            if(i < 10){

                System.out.println("目前i的值为" + i);
                i++;
            }else {
                Thread.currentThread().interrupt();
            }
        }

    }
}

MyThread

package com.lv;

/**
 * Created by LocalUser on 2018/4/24.
 */
public class MyThread extends Thread{


    private boolean on = true;


    private int i = 0;
    @Override
    public void run() {

        while (on){
            if(i < 10){
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("目前i的值为" + i);
                i++;
            }else {
                on = false;
            }
        }
        System.out.println(Thread.currentThread().getId() + "线程执行中");
    }
}

AtomicTest

package com.lv;

import java.util.concurrent.atomic.AtomicInteger;

/**
 * Created by LocalUser on 2018/5/9.
 */
public class AtomicTest {


    private AtomicInteger atomicInteger = new AtomicInteger();
    public static void main(String[] args){
        AtomicTest atomicTest = new AtomicTest();

        System.out.println(atomicTest.atomicInteger.get());

    }
}

LockTest

package com.lv;

import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * Created by LocalUser on 2018/5/9.
 */
public class LockTest implements Runnable{

    private static int i = 0;

    private ReentrantLock lock = new ReentrantLock();

    private ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
    /*public void increase(){

        lock.lock();
        try{
            i++;
        }finally {
            lock.unlock();
        }

    }*/


    /*public void increase()throws InterruptedException{

        if(lock.tryLock(1, TimeUnit.SECONDS)){
            try{
                i++;
            }finally {
                lock.unlock();
            }
        }else{
            System.out.println("获取锁失败");
        }


    }*/

    public void increase() throws InterruptedException {

        //lock.lockInterruptibly();
        //rwLock.readLock().lockInterruptibly();
        rwLock.writeLock().lockInterruptibly();
        try{
            i++;
        }finally {
            //lock.unlock();
            //rwLock.readLock().unlock();
            rwLock.writeLock().unlock();
        }

    }
    @Override
    public void run() {
        for (int j = 0; j < 10000000; j++) {
            try {
                increase();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args){
        LockTest lockTest = new LockTest();

        Thread t1 = new Thread(lockTest);
        Thread t2 = new Thread(lockTest);


        t1.start();
        t2.start();
        try {
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("i的值为 "+i);
    }
}

CountDownLatchTest

package com.lv;

import java.util.Random;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * Created by LocalUser on 2018/5/16.
 */
public class CountDownLatchTest {

    static int num = 10;
    static CountDownLatch countDownLatch = new CountDownLatch(num);
    static AtomicInteger result = new AtomicInteger(0);
    static Random random=new Random();


    static class Parse implements Runnable{
        @Override
        public void run() {
            int sum=0;
            for(int i=1;i<100;i++){
                sum+=random.nextInt(i);
            }

            result.addAndGet(sum);
            countDownLatch.countDown();
            System.out.println(Thread.currentThread().getId() + " 解析完一个sheet,结果为 " + sum);
        }
    }

    public static void main(String[] args){
        for (int i = 0; i < num; i++) {
            new Thread(new Parse()).start();
        }

        try {
            countDownLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("所有sheet解析完毕,最终结果" + result);
    }
}

CyclicBarrierTest

package com.lv;

import java.util.Random;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * Created by LocalUser on 2018/5/16.
 */
public class CyclicBarrierTest {


    static int num = 10;
    static CyclicBarrier cyclicBarrier = new CyclicBarrier(num,new Aculate());
    static AtomicInteger result = new AtomicInteger(0);
    static Random random=new Random();


    static class Parse implements Runnable{
        @Override
        public void run() {
            int sum=0;
            int seed = Math.abs(random.nextInt());
            for(int i=1;i<100;i++){
                sum+=random.nextInt(seed);
            }

            result.addAndGet(sum);
            System.out.println(System.currentTimeMillis() + " 解析完一个sheet,结果为 " + sum);

            try {
                cyclicBarrier.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (BrokenBarrierException e) {
                e.printStackTrace();
            }

            System.out.println(System.currentTimeMillis() + " 越过屏障");
        }
    }


    static class Aculate implements Runnable{
        @Override
        public void run() {
            System.out.println("所有sheet解析完毕,最终结果" + result);
        }
    }
    public static void main(String[] args){
        for (int i = 0; i < num; i++) {
            new Thread(new Parse()).start();
        }




    }
}

SemaphoreTest

package com.lv;

import java.util.Random;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;


/**
 * Created by LocalUser on 2018/5/16.
 */
public class SemaphoreTest {


    static int num = 30;
    static Semaphore semaphore = new Semaphore(10);
    static Random random = new Random();
    static ExecutorService threadPool = Executors.newFixedThreadPool(num);


    public static void main(String[] args){


        for (int i = 0; i < num; i++) {
            threadPool.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        semaphore.acquire();

                        int sum = 0;
                        for (int i = 1; i < 100; i++) {
                            sum += random.nextInt(i);

                        }
                        System.out.println(Thread.currentThread().getId() + " 执行完save data 结果为 " + sum);

                        Thread.sleep(2000);
                        semaphore.release();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
        threadPool.shutdown();
    }

}

ProCus

package com.lv;

import java.util.PriorityQueue;

/**
 * Created by LocalUser on 2018/5/16.
 */
public class ProCus {

    private int queueSize = 10;
    private PriorityQueue<Integer> queue = new PriorityQueue<Integer>(queueSize);



    class Producer extends Thread{
        public void run(){

            produce();
        }

        public void produce()  {
            while(true){
                synchronized (queue){
                    while(queue.size() == queueSize){
                        System.out.println("queue的大小满了!等待消费者消费");
                        try {
                            queue.notify();
                            queue.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }

                    queue.offer(1);
                    System.out.println("生产一个包子,总共" + queue.size());


                }
            }
        }
    }


    class Consumer extends Thread{
        public void run(){

            consume();

        }

        public void consume() {
            while(true){
                synchronized (queue){
                    while(queue.isEmpty()){
                        System.out.println("queue的大小为空!等待生产者生产");
                        try {
                            queue.notify();
                            queue.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }

                    queue.poll();
                    System.out.println("消费了一个包子,还剩" + queue.size());

                }
            }
        }
    }

    public static void main(String[] args){
        ProCus proCus = new ProCus();

        Producer producer = proCus.new Producer();
        Consumer consumer = proCus.new Consumer();


        consumer.start();

        producer.start();
    }
}

ProCusCondition

package com.lv;

import java.util.PriorityQueue;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

/**
 * Created by LocalUser on 2018/5/16.
 */
public class ProCusCondition {

    private int queueSize = 10;
    private PriorityQueue<Integer> queue = new PriorityQueue<Integer>(queueSize);
    private ReentrantLock lock = new ReentrantLock();
    private Condition empty = lock.newCondition();
    private Condition full = lock.newCondition();


    class Producer extends Thread{
        public void run(){

            produce();
        }

        public void produce()  {
            while(true){
                lock.lock();
                try{
                    while(queue.size() == queueSize){
                        System.out.println("queue的大小满了!等待消费者消费");
                        try {
                            empty.signal();
                            full.await();

                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }

                    queue.offer(1);
                    System.out.println("生产一个包子,总共" + queue.size());


                }finally {
                   lock.unlock();
                }
            }
        }
    }


    class Consumer extends Thread{
        public void run(){

            consume();

        }

        public void consume() {
            while(true){
                lock.lock();
                try{
                    while(queue.isEmpty()){
                        System.out.println("queue的大小为空!等待生产者生产");
                        try {
                            full.signal();
                            empty.await();

                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }

                    queue.poll();
                    System.out.println("消费了一个包子,还剩" + queue.size());


                }finally {
                    lock.unlock();
                }
            }
        }
    }

    public static void main(String[] args){
        ProCusCondition proCus = new ProCusCondition();

        Producer producer = proCus.new Producer();
        Consumer consumer = proCus.new Consumer();


        consumer.start();

        producer.start();
    }
}

User

package com.lv;

/**
 * Created by LocalUser on 2018/4/24.
 */
public class User extends Thread{

    public static final String CITY = "ShenZhen";
    private int age;
    private String address;

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public User(int age, String address) {
        this.age = age;
        this.address = address;
    }

    public synchronized void waitAge() {
        while (30 > age){
            try {
                System.out.println("当前线程waitAge" + Thread.currentThread().getId() + " is wait");
                wait();
                System.out.println("当前线程waitAge" + Thread.currentThread().getId() + " is notified");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        System.out.println("当前user的age" + age);

    }

    public synchronized void waitAddress() {

        while (CITY.equals(address)){
            try {
                System.out.println("当前线程waitAddress" + Thread.currentThread().getId() + " is wait");
                wait();
                System.out.println("当前线程waitAddress" + Thread.currentThread().getId() + " is notified");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        System.out.println("当前user的address" + address);

    }

    public synchronized void notifyAddress() {

        notifyAll();

    }

    public synchronized void notifyAge() {

        notifyAll();
    }
}

Test

package com.lv;

/**
 * Created by LocalUser on 2018/5/9.
 */
public class Test {

    private static User user = new User(29,User.CITY);

    static class CheckAge extends Thread{
        public void run(){
            user.waitAge();
        }
    }

    static class CheckAddress extends Thread{
        public void run(){
            user.waitAddress();
        }
    }


    public static void main(String[] args){

        for (int i = 0; i < 3; i++) {
            CheckAge checkAge = new CheckAge();
            checkAge.start();
        }

        for (int i = 0; i < 3; i++) {
            CheckAddress checkAddress = new CheckAddress();
            checkAddress.start();
        }

        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }


        user.setAddress("NewYork");
        user.notifyAddress();
    }
}

SyncTest

package com.lv;

/**
 * Created by LocalUser on 2018/5/15.
 */
public class SyncTest implements Runnable{


    private static int i = 0;

    /*public synchronized void increase(){
        i++;
    }*/

    /*public static synchronized void increase(){
        i++;
    }*/

    /*public void increase(){
        synchronized (this){
            i++;
        }

    }*/

    public void increase(){
        synchronized (SyncTest.class){
            i++;
        }

    }
    @Override
    public void run() {
        for (int j = 0; j < 10000000; j++) {
            increase();
        }
    }

    public static void main(String[] args){
        SyncTest syncTest = new SyncTest();

        /*Thread t1 = new Thread(syncTest);
        Thread t2 = new Thread(syncTest);*/

        Thread t1 = new Thread(new SyncTest());
        Thread t2 = new Thread(new SyncTest());

        t1.start();
        t2.start();
        try {
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("i的值为 "+i);
    }
}

 

C++多线程编程：深入剖析std::thread的使用方法
Lion_Long的博客
11-18 8914
C++11 thread的语法、构造函数、主要成员函数、简单线程的创建详解。 介绍线程封装。更多函数std::this_thread、std::this_thread::get_id()、std::this_thread::yield()、std::this_thread::sleep_for等的使用。
【JavaSE】【多线程】Thread类讲解
最新发布
yj20040627的博客
10-08 4211
Thread类解析，创建/终止/等待线程，获取当前线程，线程状态/安全，synchronized加锁解决非原子性操作线程不安全
【多线程】Thread类的使用
weixin_73950267的博客
03-11 1183
Thread类的使用
Thread类的使用
bobolan
10-17 295
一.线程的状态 在学习Thread类中的具体方法之前，先了解一下线程有哪些状态，这个将会有助于后面对Thread类中的方法的理解。 线程从创建到最终的消亡，要经历若干个状态。一般来说，线程包括以下这几个状态：创建(new)、就绪(runnable)、运行(running)、阻塞(blocked)、time waiting、waiting、消亡（dead）。 当需要新起一个线程来执行某个子任务时...
Thread线程简单使用
Heart-Attack的专栏
01-06 916
这是自己以前学习线程时所做的一些总结 一：创建一个线程 继承Thread  类  线程类（Thread）包含一个可以运行的过程（方法）：run()方法  2)  创建一个具体线程的步骤如下： 第一，继承 Thread 类 第二，重写 run 方法（就是更新运行过程）,  实现用户自己的过程 第三，创建线程实例（就是创建一个线程） 第四，使用线程实例的 start()  方法
多线程——thread的基本使用
weixin_42137701的博客
04-11 562
一、多任务介绍及Thread的基本使用 什么叫多任务呢？ 简单地说，就是操作系统可以同时运行多个任务，有些事情是需要同时实现的，比如一边唱歌，一边跳舞，这就是多任务。 这里我们举个例子。 首先，按照传统的方式，分别创建一个唱歌和跳舞的方法，在让他们分别每隔1s打印响应的log。 import time def sing(): for i in range(4): prin...
多线程编程全攻略：提升性能与线程安全的必备知识
热门推荐
张彦峰的博客
10-14 10万+
介绍多线程编程的相关概念、同步机制以及无锁编程。从线程的基础概念出发，包括逻辑线程和硬件线程的比较，以及线程、核心和函数的关系。随后，我们探讨了多线程编程的基本原则，包括时间分片、上下文切换、线程安全函数和可重入函数等。接着，我们讨论了为什么需要多线程同步、什么情况需要进行同步以及多线程同步的方式，包括串行化、原子操作和锁等。我们还深入研究了非阻塞的无锁同步机制，如CAS循环和无锁数据结构。最后，我们解释了程序序、内存序、乱序执行、存储缓冲区和失效队列等概念，以帮助更好地理解多线程编程。
Java多线程之线程的创建与Thread类的使用
未见花闻的博客
03-29 2853
本篇文章介绍java多线程中Thread类的使用以及有关线程对象创建和常用方法。
Java多线程Thread
qq_43609524的博客
04-19 1893
Java多线程Thread多线程实现原理线程内存图创建多线程的多种方法自定义Thread子类实现Runnable接口实现Runnable接口创建多线程程序的好处使用匿名内部类线程的方法获取线程的名称设置线程名称线程暂停（睡眠）方法 sleep 多线程实现原理 线程内存图 创建多线程的多种方法 自定义Thread子类 class MyThread extends Thread{ @Override public void run() { for (int i = 0; i
Thread的基本用法
m0_64318128的博客
11-29 3136
Thread类中一些常用方法和属性的使用和特点
Thread类基本用法及线程的基本操作
2302_78814792的博客
07-17 961
使用start()方法时，会启动一个新的线程来执行run()方法中的代码。这意呀着run()方法中的代码会在新的线程中并发执行，不会阻塞调用start()方法的线程。这使得程序能够同时执行多个任务，提高了程序的执行效率。 直接调用run()方法：直接调用run()方法时，并不会启动新的线程，而是直接在当前线程中顺序执行run()方法中的代码。这意味着run()方法中的代码执行会阻塞调用它的线程，直到run()方法执行完毕。这与多线程的初衷相悖，因为并没有实现真正的并发执行。
Thread常用使用方法
小目标一个亿
05-09 7829
1、定义线程委托 ThreadStart method = () => { //执行代码 }; 2、初始化线程 Thread thread = new Thread(methodA); 3、开启线程 thread.Start(); 4、线程等待X毫秒执行 thread.Sleep(X);//这个是同步的 程序会卡X毫秒 5、暂停线程 thread.Suspend(); 6、恢复线程 thread.Resume()...
Thread 类的基本用法
weixin_52758364的博客
04-01 1175
线程之间是并发执行的，操作系统对于系统的调度，是无序的，无法判定两个线程谁先执行结束，谁后执行结束！
线程Thread类的基本用法
weixin_57190845的博客
07-25 447
java中线程Thread类的基本用法
线程thread的使用
red_rock的博客
09-10 275
#include #include #include #include #include #include pthread_t thread; sem_t sem_r, sem_w; int a[10] = {4,5,41,23,36,8,7,14,36,12}; static int len = sizeof(a); static int i = 0; static int j = 9;
thread 线程使用和解析
镜子蓝玉的专栏
11-25 1326
C++11 例子1：
Thread 类的基本用法——一网打尽
日常学习记录、分享，愿我们都遇见更好的自己，与诸君共勉
07-30 989
线程创建、线程中断、线程等待、线程休眠、获取线程实例😁这些线程的基本用法，你还记得吗🤔
深入理解Java线程Thread实例解析
标签提到的“线程Thread和Java”，意味着要理解Java语言是如何支持线程操作的。Java提供了丰富的线程API，包括Thread类、Runnable接口、同步机制（synchronized关键字、Lock接口）、线程状态控制（wait(), notify(),...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值