多线程笔记2

最新推荐文章于 2014-08-28 00:29:25 发布
最新推荐文章于 2014-08-28 00:29:25 发布
阅读量2.6k 收藏 1
点赞数
分类专栏： C/C++ 多线程技术 文章标签： c++ 多线程 生产消费者
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/stalendp/article/details/9310171
版权

转发，请保持地址：http://blog.csdn.net/stalendp/article/details/9310171

以前学习过Java的多线程设计，出于对java多线程设计的熟悉，我把pthread的多线程方法按照java的习惯封装了一下，并写了几个例子，分享一下。

// ThreadHelper.h


#ifndef threadTest_ThreadHelper_h
#define threadTest_ThreadHelper_h

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string>

void msleep(unsigned sec) {
    usleep(sec*1000);
}

// 参考 http://stackoverflow.com/questions/1151582/pthread-function-from-a-class
class Thread {
protected:
    std::string name;
    pthread_t mythread;
    pthread_mutex_t mymutex;
    pthread_cond_t mycond;
    
protected:
    virtual void* run() = 0;
public:
    Thread() {
        pthread_mutex_init(&mymutex, NULL);
        pthread_cond_init(&mycond, NULL);
        char msg[50];
        sprintf(msg, "%ld", time(NULL));
        name = msg;
    }
    
    Thread(const char* _name) : name(_name) {
        pthread_mutex_init(&mymutex, NULL);
        pthread_cond_init(&mycond, NULL);
    }
    
    virtual ~Thread() {
        pthread_mutex_destroy(&mymutex);
        pthread_cond_destroy(&mycond);
    }
    
    const char* getName() {
        return name.c_str();
    }
    
    void start() {
        if ( pthread_create( &mythread, NULL, _run, this) ) {
            printf("error creating thread.");
            abort();
        }
    }
    
private:
    static void* _run(void* This) {
        return ((Thread*) This)->run();
    }
};

class Synchronizable {
protected:
    pthread_mutex_t mymutex;
    pthread_cond_t mycond;
    
public:
#define LOCK_BEGIN  pthread_mutex_lock(&mymutex)
#define LOCK_END    pthread_mutex_unlock(&mymutex)
#define WAIT        pthread_cond_wait(&mycond, &mymutex)
#define NOTIFY_ALL  pthread_cond_broadcast(&mycond);
    
public:
    Synchronizable() {
        pthread_mutex_init(&mymutex, NULL);
        pthread_cond_init(&mycond, NULL);
    }
    
    virtual ~Synchronizable() {
        pthread_mutex_destroy(&mymutex);
        pthread_cond_destroy(&mycond);
    }

};

#endif

然后给出一个生产消费者模式的例子： 

#ifndef threadTest_PtProducerConsumer_h
#define threadTest_PtProducerConsumer_h

#include "ThreadHelper.h"

#include <pthread.h>
#include <stdlib.h>
#include <unistd.h>
#include <stdio.h>
#include <time.h>
#include <string>
#include <vector>
#include <sstream>

// 生产者必须将数据安全地交给消费者。虽然只是这样的问题，但当生产者与消费者
// 在不同的线程上运行时，两者的处理速度差将是最大的问题。当消费者要取数据时
// 生产者还没有建立出数据，或是生产者建立出数据时消费者的状态还没办法接受数据等。
// Producer-Consumer Pattern是在生产者和消费者之间加入一个“桥梁参与者”。
// 以这个桥梁参与者缓冲线程之间的处理速度差。


class Table : Synchronizable {
private:
    int tail, head, count;
    std::vector<std::string> buffer;


public:
    Table(int _count) : tail(0), head(0), count(0) {
        buffer.resize(_count);
    }


    void put(const char* cake) {
        LOCK_BEGIN;
        while (count >= buffer.size()) {
            printf("!!!TABLE IS FULL!!!\n");
            fflush(stdout); // flush stdout for windows
            WAIT;
        }
        buffer[tail] = cake;
        tail = (tail+1) % buffer.size();
        count++;
        NOTIFY_ALL;
        printf("puts  %s -- size %d\n", cake, count);
        fflush(stdout);
        LOCK_END;
    }


    const char* take() {
        LOCK_BEGIN;
        while (count<=0) {
            printf("!!!NO MORE CAKES!!!\n");
            WAIT;
        }
        std::string cake = buffer[head];
        head = (head+1) % buffer.size();
        count--;
        NOTIFY_ALL;
        printf("takes %s -- size %d\n", cake.c_str(), count);
        fflush(stdout);
        LOCK_END;
        return cake.c_str();
    }
};


static int mid;


class MakerThread: public Thread {
private:
    Table* table;
public:
    MakerThread(const char* _name, Table* _table) : Thread(_name) {
        this->table = _table;
        srand((unsigned)time(NULL));
    }
    void* run() {
        while (true) {
            msleep(rand()%1000);
            std::stringstream ss;
            ss << "[Cake No." << nextId() << " by " << getName()  << "]";
            table->put(ss.str().c_str());
        }
        return NULL;
    }


    static int nextId() {
        return mid++;
    }
};


class EaterThread: public Thread {
private:
    Table* table;
public:
    EaterThread(const char* _name, Table* _table) : Thread(_name) {
        this->table = _table;
    }


    void* run() {
        while (true) {
            const char* cake = table->take();
//            printf("%s\n", cake);
            msleep(rand()%1000);
        }
        return NULL;
    }
};


void pcRun() {
    Table* table = new Table(3);  // 建立可以放置3个蛋糕的桌子
    (new MakerThread("MakerThread-1", table))->start();
    (new MakerThread("MakerThread-2", table))->start();
    (new MakerThread("MakerThread-3", table))->start();
    (new EaterThread("EaterThread-1", table))->start();
    (new EaterThread("EaterThread-2", table))->start();
    (new EaterThread("EaterThread-3", table))->start();
    msleep(90 * 1000);
    getchar();
    printf("hello producer consumer");
}

#endif



读写锁 (未完成)

#include "ThreadHelper.h"

#include <pthread.h>
#include <stdlib.h>
#include <unistd.h>
#include <stdio.h>
#include <time.h>
#include <string>
#include <vector>
#include <sstream>

/*
 当线程“读取”实例的状态时，实例的状态不会变化。会使实例状态变化的，只有线程对线程“写入”
 的操作而已。把视点放在实例状态变化的角度来看时，“读取”与“写入”本身时不同的东西。
    Read-Write Lock Pattern将读取与写入分开来处理。在读取数据之前，必须获取用来读取
 的锁定。而要写入的时候，则必须获取用来写入的锁定。
    因为进行读取时，实例的状态不会改变，所以，就算有多个线程在同时读取也没有关系。但，有人
 在读取的时候，不可以做写入的操作。
    写入的时候，实例的状态就会改变。于是，当有一个线程在写入的时候，其他线程就不可以有进行
 读取和写入。
    一般来说，进行共享互斥会时线程性能变差，但将写入的共享互斥与读取的共享互斥分开来考虑，
 就可以提升成效的性能。
 */


class ReadWriteLock : public Synchronizable {
private:
    int readingReaders, waitingWriters, writingWriters;
    bool preferWriter;
    
public:
    void readLock() {
        while (writingWriters>0 || (preferWriter&&waitingWriters>0) ) {
            WAIT;
        }
        readingReaders++;
    }
    
    void readUnlock() {
        readingReaders--;
        preferWriter = true;
        NOTIFY_ALL;
    }
    
    void writeLock() {
        waitingWriters++;
        while (readingReaders>0 || writingWriters>0) {
            WAIT;
        }
        waitingWriters--;
        writingWriters++;
    }
    
    void writeUnlock() {
        writingWriters--;
        preferWriter = false;
        NOTIFY_ALL;
    }
    
};

class Data  {
private:
    std::string buffer;
    ReadWriteLock* lock;
public:
    Data(int size) {
        buffer.resize(size, '*');
        lock = new ReadWriteLock();
    }
    
    virtual ~Data() {
        delete lock;
    }
    
    char* read() {
        lock->readLock();
        char* rt = doRead();
        lock->readUnlock();
        return rt;
    }
    
    void write(char c) {
        lock->writeLock();
        doWrite(c);
        lock->writeUnlock();
    }
    
    char* doRead() {
        
        return NULL;
    }
    
    void doWrite(char c) {
        
    }
    
    void slowly() {
        msleep(50);
    }
};


class WriterThread: public Thread {
private:
    Data* data;
    std::string filler;
    int index;
    
public:
    WriterThread(Data* _data, const char* _filler) : data(_data), filler(_filler), index(0)  {
    }
    
    void* run() {
        while (true) {
            char c = nextchar();
            data->write(c);
            msleep(rand()%3000);
        }
        return NULL;
    }
    
    char nextchar() {
        char c = filler.at(index);
        index++;
        if (index>=filler.size()) {
            index = 0;
        }
        return c;
    }
};

class ReaderThread: public Thread {
private:
    Data* data;
    
public:
    ReaderThread(Data* _data) : data(_data) {
    }
    
    void* run() {
        while (true) {
            char* readbuf = data->read();
            printf("reads %s\n", readbuf);
        }
        return NULL;
    }
};


void rwlRun() {
    Data* data = new Data(10);
    (new ReaderThread(data))->start();
    (new ReaderThread(data))->start();
    (new ReaderThread(data))->start();
    (new ReaderThread(data))->start();
    (new ReaderThread(data))->start();
    (new ReaderThread(data))->start();
    
    (new WriterThread(data, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"))->start();
    (new WriterThread(data, "abcdefghijklmnopqrstuvwxyz"))->start();
    
    printf("hello read write lock\n");
}

#endif



参考：《Java多线程设计模式详解》

相关文章： http://blog.csdn.net/stalendp/article/details/9253665


stalendp
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
多线程笔记
12-28
多线程笔记，包含线程创建，线程开启，线程命名，线程同步
Java多线程笔记
03-11
多线程学习笔记，好资源。包括线程基础等知识多线程学习笔记，好资源。包括线程基础等知识
马士兵多线程笔记.zip
02-21
马士兵多线程训练营上课笔记
多线程学习笔记
03-18
多线程学习笔记，通过平时的学习所做的一些笔记，希望对广大同仁有所帮助
【OpenGL】使用Unity来学习OpenGL
热门推荐
stalendp的专栏
09-09 3万+
转发，请保持地址：http://blog.csdn.net/stalendp/article/details/11492525 OpenGL是原理性和实践性比较强的一门技术，在学习的时候，如果能够跟着书中的例子，一边调试一边学习，效果将很好（这属于实验的一种类型吧，能够吧知识形象化，有助于学习兴趣的提高）。市面上有许多深入浅出的书籍讲的很好，比如《OpenGL SuperBible 5th
[cocos2dx开发技巧2]工具CocosBuilder的使用--集成
stalendp的专栏
04-03 2万+
转发，请保持地址：http://blog.csdn.net/stalendp/article/details/8756467 本文主要侧重于CocosBuilder在cocos2dx中的集成。对CocosBuilder使用的介绍比较简单。详细的使用请参考官方教程； CocosBuilder部分 1）创建工程 首先创建Cocos2dx工程“ShootTheApple”，然后在其Resourc
【cocos2dx开发技巧10】cocosStudio的集成以及c++11的新特性
stalendp的专栏
08-28 1万+
很长时间没有碰cocos2dx了，最近又用起来了，花了好几个小时重新熟悉了一下，发现很多新的特性值得用来写文章。好吧，先从最常用的开始。最近用windows，使用cocosStudio，就从这个开始吧，顺带介绍一下工程的创建，以及c++11的特性。以前开发使用cocosBuilder开发界面（相关集成见这篇文章）。 准备工作 1）准备NDK、andrdoid-SDK，VisualStudio等
【cocos2dx开发技巧7】脚本lua的使用--集成cocosbuilder
stalendp的专栏
06-23 1万+
转发，请保持地址：http://blog.csdn.net/stalendp/article/details/9154485 由于cocosBuilder几乎包办了游戏界面的编程，所以自己在上一版cocos2dx中（还没在lua中对cocosbuilder进行集成），我就自己实现了套集成方案，一直想写出来，但是由于改动了lib中的代码，解释起来也不那么容易，所以一直耽搁了；刚刚发布的新版本中，c
【cocos2dx开发技巧8】自定义控件－使自定义控件具有RGBA特性
stalendp的专栏
08-13 8045
虽然CCNodeRGBA，CCLayerRGBA，sprite等提供颜色和透明度的设置，但有时候要自定义控件，要自己去实现那些功能。比如，我要扩充一个CCSpriteBatchNode，同时要要具有颜色和透明度的设置，这个时候就需要自己动手了。 其实为自己的控件添加RGBA特性并不是很难，只要继承CCRGBAProtocol，然后把CCNodeRGBA的实现方案贴到新加的类中就可以了。不过这样不
【cocos2dx开发技巧9】自定义控件－定制字体工具
stalendp的专栏
08-13 7302
在Cocos2dx中已经有三种字体工具了，几本上能够满足游戏中对字体的要求。其中CCLabelTTF使用系统的ttf文件，CCLabelBMFont字体工具制作，CCLabelAtlas使用贴图，不过字体的大小要相同等约束。CCLabelTTF最为方便，速度最慢，效果最少；CCLabelBMFont方便性速度效果等都居中，CCLabelAtlas不太方便，不过性能和效果最优，可以使用美工制作的字体
[cocos2dx开发技巧4]工具CocosBuilder的使用--复杂动画
stalendp的专栏
04-05 7128
转发，请保持地址：http://blog.csdn.net/stalendp/article/details/8760957 一个网友推荐过一款制作动画的工具，叫做 Spriter； 其中有个Demo介绍怎么制作游戏中的boss，十分精彩；Sprite的Demo地址为：How to use Spriter 0；资源下载地址：Monster;  这篇文章中，我将使用CocosBuilder来
【cocos2dx开发技巧6】脚本lua的使用--开发环境的配置
stalendp的专栏
05-14 7023
转发，请保持地址：http://blog.csdn.net/stalendp/article/details/8920018 在cocos2dx中使用lua进行开发的过程中，肯定会涉及到对lua功能进行扩充的情况，网络上已经有相关的文章，不过不是那么简单明了。所以我这里特意写了这篇文章，也是作为自己学习的一个总结吧。这里我将使用Eclipse来开发lua。使用eclipse开发lua，可以运
在cocos2dx中怎么使用sqlite来纪录数据
stalendp的专栏
04-28 6261
转发，请保持地址：http://blog.csdn.net/stalendp/article/details/8862737 花了一些时间来调查sqlite在cocos2dx中的集成，在这个过程中遇到了些问题，特意纪录下来。 1）下载sqlite源代码，并解压到工程中［这步不需要了，cocos2dx中已经加入了sqlite，只需引用头文件sqlite3.h就可以了］： 源代码位置：htt
【Server】Socket编程原理详解
stalendp的专栏
10-04 6091
这篇文章将对一个简单的socket例程进行剖析。 这里提供的例子就是一个简单的TCP client／server程序，client主动连接server，并从服务器中得到一条欢迎消息：“[server] welcome client!”。程序的流程参考如下： 参考代码如下： server端： #include #include #include #include #inc
[cocos2dx开发技巧3]工具CocosBuilder的使用--Box2d
stalendp的专栏
04-03 5869
转发，请保持地址：http://blog.csdn.net/stalendp/article/details/8757660 前面的文章，我介绍了cocosBuilder的简单集成，这篇将介绍怎么使用cocosBuilder开发物理类的游戏。 机器人模型 先介绍结合机器人模型。如下图，机器人有10个图片组合而成，我们先要在cocosBuilder中把各种图片位置摆正确，然后在代码中读取图片之
[cocos2dx开发技巧1]工具CocosBuilder的使用--demo介绍
stalendp的专栏
04-03 5518
转发，请保持地址：http://blog.csdn.net/stalendp/article/details/8755958 最近在接触CocosBuilder之后，发现这是一款非常优秀的软件，可以加快cocos2dx的开发速度。我在研究的过程中，写了一个demo，现在陆续分享出来，希望得到大家的支持。 这个demo介绍了在Cocos2dx中集成CocosBuilder实现动画等技巧，还结合B
【cocos2dx开发技巧5】脚本lua的使用--代码集锦
stalendp的专栏
05-05 4057
仿照“我叫MT”的控件 代码如下： local function createBanner() local layerFarm = CCNode:create() local cache = CCSpriteFrameCache:sharedSpriteFrameCache() cache:addSpriteFramesWithFile("pic.plist") l
Sqlite的编译、使用和调试
stalendp的专栏
09-08 3809
首先准备好gcc的编译环境，这里我用的是mingw。 然后下载sqlite3的源代码。 然后用如下的命令进行编译： gcc -DSQLITE_DEBUG -ggdb *.c -o sqlite3 其中的编译参数“SQLITE_DEBUT”是过会用来理解sqlite
狂神说java多线程笔记
最新发布
10-11
Java多线程是Java语言中的一个重要特性，可以让程序同时执行多个任务，提高程序的效率和性能。狂神在他的Java多线程笔记中，详细介绍了Java多线程的相关知识，包括线程的创建、启动、停止、等待、唤醒等操作，以及线程安全、锁、同步等概念和技术。 在Java多线程中，线程的创建有两种方式：继承Thread类和实现Runnable接口。其中，实现Runnable接口更为常用，因为它可以避免单继承的限制，并且更符合面向对象的设计原则。 线程的启动使用start()方法，而不是run()方法。start()方法会启动一个新的线程，并在新线程中执行run()方法中的代码。 线程的停止可以使用stop()方法，但这个方法已经被废弃了，因为它可能会导致线程不安全。更好的方式是使用interrupt()方法来中断线程，并在run()方法中检查中断标志位来安全地停止线程。 线程的等待和唤醒可以使用wait()、notify()和notifyAll()方法来实现。wait()方法会使当前线程进入等待状态，并释放锁；notify()和notifyAll()方法会唤醒等待在同一个对象上的其他线程。 线程安全是指多个线程同时访问共享资源时，不会出现数据不一致或者程序崩溃等问题。为了保证线程安全，可以使用锁和同步机制来控制对共享资源的访问。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值