/*============================================================================
// Name        : thread_privateData.cpp
// Author      : Ryan
// Version     :
// Copyright   : zjut
// Description : 測試執行緒私有資料
//============================================================================*/

#include <iostream>
#include <stdio.h>
#include <pthread.h>
//#include "../errors.h"
using namespace std;

struct private_tag{
        pthread_t thread_id;
        char *thread_name;
};

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_key_t key;
int count = 0;

void *key_get(void *arg)
{
        void *value = NULL;
        int status;

        value = pthread_getspecific(key);
        if(value == NULL){

                value = new private_tag;//建立資料的動態記憶體
                //初始化資料
                ((private_tag *)value)->thread_id = pthread_self();
                ((private_tag *)value)->thread_name = (char *)arg;

                if(value == NULL){
                        cout<<"new"<<endl;
                }
                cout<<pthread_self()<<" value: "<<value<<endl;
                status = pthread_setspecific(key, value);
                if(status != 0){
                	cout<<status<<"pthread_setspecific"<<endl;

                }
        }
        return value;
}

void *thread_routine(void *arg)
{
		private_tag *value = NULL;

        value = (private_tag *)key_get(arg);
        //核對執行緒資料
        cout<<"thread_id:"<<value->thread_id<<" thread_name:"<<value->thread_name<<endl;
        //核對key值
        cout<<(value->thread_id)<<" key: "<< pthread_getspecific(key)<<endl;
        sleep(1);
        return 0;
}
//解構函式
void destructor(void *arg)
{
		private_tag *_private = (private_tag *)arg;
        int status;

        printf("\"%s\" exiting......\n", _private->thread_name);
//        free(arg);
        delete (private_tag*)arg;

        status = pthread_mutex_lock(&mutex);//lock
        if(status != 0){
        	cout<<"mutex lock erro"<<status<<endl;
        }

        count--;
        if(count <= 0)
        {
                status = pthread_key_delete(key);
                if(status != 0){
                	cout<<"pthread_delete erro"<<status<<endl;
                }
                printf("key deleted......\n");
        }

        status = pthread_mutex_unlock(&mutex);//unlock
        if(status != 0){
        	cout<<"mutex unlock erro"<<status<<endl;
        }
}

int main(int argc, char **argv)
{
        int status;
        pthread_t thread1, thread2;
        private_tag *value = NULL;

        status = pthread_key_create(&key, destructor);
        if(status != 0){
        	cout<<"pthread_key_created"<<status<<endl;
        }

        count = 2;
//        value = (private_tag *)key_get();
//        value->thread_id = pthread_self();
//        value->thread_name = "main thread";
        char *thread_1 = "thread 1";
        char *thread_2 = "thread 2";

        status = pthread_create(&thread1, NULL, thread_routine, thread_1);
        if(status != 0){
        	cout<<"create thread1"<<status<<endl;
        }

        status = pthread_create(&thread2, NULL, thread_routine, thread_2);
        if(status != 0){
        	cout<<"create thread2"<<status<<endl;
        }
        pthread_join(thread1, NULL);
        cout<<"thread1 exited"<<endl;
        pthread_join(thread2, NULL);
        cout<<"thread2 exited"<<endl;
        pthread_exit(NULL);
}