void
ags_lv2_option_manager_finalize(GObject *gobject)
{
  AgsLv2OptionManager *lv2_option_manager;

  lv2_option_manager = AGS_LV2_OPTION_MANAGER(gobject);
  
  g_hash_table_destroy(lv2_option_manager->ressource);

  if(lv2_option_manager == ags_lv2_option_manager){
    ags_lv2_option_manager = NULL;
  }

  pthread_mutex_destroy(lv2_option_manager->obj_mutex);
  free(lv2_option_manager->obj_mutex);

  pthread_mutexattr_destroy(lv2_option_manager->obj_mutexattr);
  free(lv2_option_manager->obj_mutexattr);

  /* call parent */
  G_OBJECT_CLASS(ags_lv2_option_manager_parent_class)->finalize(gobject);  
}

/*
 * Initialize slog library. Function parses config file and reads log 
 * level and save to file flag from config. First argument is file name 
 * where log will be saved and second argument conf is config file path 
 * to be parsedand third argument lvl is log level for this message.
 */
void slog_init(const char* fname, const char* conf, int lvl, int flvl, int t_safe)
{
    int status = 0;

    /* Set up default values */
    slg.level = lvl;
    slg.file_level = flvl;
    slg.to_file = 0;
    slg.pretty = 0;
    slg.filestamp = 1;
    slg.td_safe = t_safe;

    /* Init mutex sync */
    if (t_safe)
    {
        /* Init mutex attribute */
        pthread_mutexattr_t m_attr;
        if (pthread_mutexattr_init(&m_attr) ||
            pthread_mutexattr_settype(&m_attr, PTHREAD_MUTEX_RECURSIVE) ||
            pthread_mutex_init(&slog_mutex, &m_attr) ||
            pthread_mutexattr_destroy(&m_attr))
        {
            printf("<%s:%d> %s: [ERROR] Can not initialize mutex: %d\n", 
                __FILE__, __LINE__, __FUNCTION__, errno);
            slg.td_safe = 0;
        }
    }

    /* Parse config file */
    if (conf != NULL) 
    {
        slg.fname = fname;
        status = parse_config(conf);
    }

    /* Handle config parser status */
    if (!status) slog(0, SLOG_INFO, "Initializing logger values without config");
    else slog(0, SLOG_INFO, "Loading logger config from: %s", conf);
}

//critical_section_t
critical_section_t::critical_section_t(bool recursive_flag) throw()
{
#ifdef LINUX

        pthread_mutexattr_t mtx_attr;
        pthread_mutexattr_init(&mtx_attr);
        if(recursive_flag) pthread_mutexattr_settype(&mtx_attr, PTHREAD_MUTEX_RECURSIVE);
        pthread_mutex_init(&_mtx, &mtx_attr);
        pthread_mutexattr_destroy(&mtx_attr);
#elif defined(WIN32)

	if(recursive_flag)
	{
		InitializeCriticalSection(&_cs);
		_sem = NULL;
	}
	else //non-recursive
	{
		_sem = ::CreateSemaphore(NULL,1,1,NULL);
	}
#endif //LINUX
}

/*! \brief Create and initialize a critical section
 *
 * UNIX/Linux
 *
 * \return Pointer to critical section created and initialized (casted to \c void *).
*/
void * PMS_CreateCriticalSection(void)
{
  pthread_mutex_t * ptCS;          /* Mutex for critical section */
  pthread_mutexattr_t mutexattr;   /* Mutex attribute variable */

  ptCS = (pthread_mutex_t *)malloc(sizeof(pthread_mutex_t));
  if(!ptCS) {
    PMS_SHOW_ERROR("Failed to allocation critical section structure\n");
    return NULL;
  }
#ifndef PMS_OIL_MERGE_DISABLE_MEM
  memVal+=sizeof(pthread_mutex_t);
#endif

  /* Initialize the attributes set */
  pthread_mutexattr_init(&mutexattr);

#ifdef MACOSX
  /* Set the mutex as a normal mutex */
  pthread_mutexattr_settype(&mutexattr, PTHREAD_MUTEX_NORMAL);
#else
#ifdef __NetBSD__
  /* Set the mutex as a normal mutex */
  pthread_mutexattr_settype(&mutexattr, PTHREAD_MUTEX_NORMAL);
#else
  /* Set the mutex as a fast mutex */
  pthread_mutexattr_settype(&mutexattr, PTHREAD_MUTEX_ADAPTIVE_NP);
#endif
#endif

  /* create the mutex with the attributes set */
  pthread_mutex_init(ptCS, &mutexattr);

  /* After initializing the mutex, the attribute can be destroyed */
  pthread_mutexattr_destroy(&mutexattr);

  return (void*)ptCS;
}

int main(void)
{
	int ret;
	pthread_t tid[2];
	pthread_attr_t attr;
	pthread_mutexattr_t mutexattr;

	pthread_attr_init(&attr);
	pthread_mutexattr_init(&mutexattr);

	pthread_attr_setdetachstate(&attr, 
		PTHREAD_CREATE_DETACHED);
	pthread_mutexattr_settype(&mutexattr,
		PTHREAD_MUTEX_RECURSIVE_NP);
	
	pthread_mutex_init(&lock, &mutexattr);
	pthread_mutexattr_destroy(&mutexattr);



	ret = pthread_create(&tid[0], &attr, 
		test0, NULL);
	if (ret) {
		fprintf(stderr, "create:%s\n", strerror(ret));
		exit(1);
	}

	ret = pthread_create(&tid[0], &attr, 
		test1, NULL);
	if (ret) {
		fprintf(stderr, "create:%s\n", strerror(ret));
		exit(1);
	}	

	pthread_attr_destroy(&attr);

	pthread_exit(NULL);
}

int initCrashSimulationThread(rtSimulationThread_t *p_thread, inputThread_t *p_inputThread)
{
	int ret;
	pthread_mutexattr_t attr;
	
	ret = initRTMutexAttr(&attr);
	if(ret != 0) {
		PRINT_ERR("Failed to init rt mutex attributes (%d).\n", ret);
		return ret;
	}
	
	ret = pthread_mutex_init(&p_thread->simulationMutex, &attr);
	if(ret != 0) {
		PRINT_ERR("Failed to init mutex (%d).\n", ret);
		return ret;
	}
	
	ret = pthread_barrier_init(&p_thread->startBarrier, NULL, 2);
	if(ret != 0) {
		PRINT_ERR("Failed to init barrier (%d).\n", ret);
		return ret;
	}
	
	ret = initSimulation(&p_thread->simulation, DEF_DISTANCE);
	if(ret != 0) {
		PRINT_ERR("Failed to init simulation (%d).\n", ret);
		return ret;
	}
	p_thread->simulate = 0;
	p_thread->keepRunning = 0;
	p_thread->running = 0;
	p_thread->exitCode = 0;
	p_thread->inputThread = p_inputThread;
	
	pthread_mutexattr_destroy(&attr);
	
	return 0;
}

static int
do_test (void)
{
  pthread_mutex_t m;

  int e = pthread_mutex_init (&m, ATTR);
  if (ATTR != NULL && e == ENOTSUP)
    {
      puts ("cannot support selected type of mutexes");
      e = pthread_mutex_init (&m, NULL);
    }
  if (e != 0)
    {
      puts ("mutex_init failed");
      return 1;
    }

  if (ATTR != NULL && pthread_mutexattr_destroy (ATTR) != 0)
    {
      puts ("mutexattr_destroy failed");
      return 1;
    }

  if (pthread_mutex_lock (&m) != 0)
    {
      puts ("1st mutex_lock failed");
      return 1;
    }

  /* Set an alarm for 1 second.  The wrapper will expect this.  */
  alarm (1);

  /* This call should never return.  */
  pthread_mutex_lock (&m);

  puts ("2nd mutex_lock returned");
  return 1;
}

int main()
{
	pthread_mutexattr_t mta;
	int rc;

	/* Initialize a mutex attributes object */
	if ((rc=pthread_mutexattr_init(&mta)) != 0)
	{
		fprintf(stderr,"Cannot initialize mutex attributes object\n");
		return PTS_UNRESOLVED;
	}

	/* Destroy the mutex attributes object */
	if (pthread_mutexattr_destroy(&mta) != 0)
	{
		fprintf(stderr,"Error at pthread_mutexattr_destroy(), rc=%d\n", rc);
		printf("Test FAILED\n");
		return PTS_FAIL;
	}

	printf("Test PASSED\n");
	return PTS_PASS;
}

int usbi_mutex_init_recursive(pthread_mutex_t *mutex, pthread_mutexattr_t *attr)
{
	int err;
	pthread_mutexattr_t stack_attr;
	if (!attr) {
		attr = &stack_attr;
		err = pthread_mutexattr_init(&stack_attr);
		if (err != 0)
			return err;
	}

	err = pthread_mutexattr_settype(attr, PTHREAD_MUTEX_RECURSIVE);
	if (err != 0)
		goto finish;

	err = pthread_mutex_init(mutex, attr);

finish:
	if (attr == &stack_attr)
		pthread_mutexattr_destroy(&stack_attr);

	return err;
}

IMutexLock::IMutexLock()
{
#ifdef  WIN32
  if (InitializeCriticalSectionAndSpinCount(&_M_mutex, 2000) != TRUE) {
    DeleteCriticalSection(&_M_mutex);
    std::cerr << "init critical section failed !" << std::endl;
  }
#elif defined(HAVE_PTHREAD)
  int       _ret_code = 0;
  if ((_ret_code = pthread_mutexattr_init(&_M_mutexattr)) != 0)
    std::cerr << "mutex attribute init failed !" << std::endl;
  if (_ret_code == 0)
    _ret_code = pthread_mutexattr_settype(&_M_mutexattr, PTHREAD_MUTEX_ERRORCHECK);
  if (_ret_code == 0)
    if ((_ret_code = pthread_mutex_init(&_M_mutex, &_M_mutexattr)) != 0)
      err_msg("pthread_mutex_init failed");

  if (_ret_code != 0) {
    (void)pthread_mutex_destroy(&_M_mutex);
    (void)pthread_mutexattr_destroy(&_M_mutexattr);
  }
#endif  // end of WIN32
}

zMutex::zMutex(void) {
  _lockedCount = 0;
  _isDestroying = false;

#if defined(_WIN32)
  _cs = new CRITICAL_SECTION;
  InitializeMutexAndSpinCount((LPCRITICAL_SECTION)_cs, 500);
#else
  pthread_mutexattr_t mutexAttr;

  int res = pthread_mutexattr_init(&mutexAttr);
  CHECK_FATAL(res, "pthread_mutexattr_init");

  res = pthread_mutexattr_settype(&mutexAttr, PTHREAD_MUTEX_RECURSIVE);
  CHECK_FATAL(res, "pthread_mutexattr_settype PTHREAD_MUTEX_RECURSIVE");

  res = pthread_mutex_init(&_mutex, &mutexAttr);
  CHECK_FATAL(res, "pthread_mutex_init");

  res = pthread_mutexattr_destroy(&mutexAttr);
  CHECK_FATAL(res, "pthread_mutexattr_destroy");
#endif
}

/**
 * Contruct our Mutex
 */
dashee::Threads::LockMutex::LockMutex()
{
    this->mutex = new pthread_mutex_t();
    this->attr = new pthread_mutexattr_t();
    
    if (pthread_mutexattr_init(this->attr) != 0)
	throw ExceptionLock("Thread attribute init failed");

    if (pthread_mutexattr_settype(this->attr, PTHREAD_MUTEX_ERRORCHECK) != 0)
	throw ExceptionLock("Thread attribute set failed");
    
    // Make sure that initilization comes out as good, otherwise we should
    // absolutly die die die
    int ec = pthread_mutex_init(this->mutex, this->attr);
    if (ec != 0)
	throw ExceptionLock(
		"Error Initilizing LockMutex, ec='" + 
		dashee::itostr(ec) + "'. This should not happen!"
	    );

    pthread_mutexattr_destroy(this->attr);
    this->attr = NULL;
}

static void *scene_create(obs_data_t settings, struct obs_source *source)
{
	pthread_mutexattr_t attr;
	struct obs_scene *scene = bmalloc(sizeof(struct obs_scene));
	scene->source     = source;
	scene->first_item = NULL;

	if (pthread_mutexattr_init(&attr) != 0)
		goto fail;
	if (pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE) != 0)
		goto fail;
	if (pthread_mutex_init(&scene->mutex, &attr) != 0) {
		blog(LOG_ERROR, "scene_create: Couldn't initialize mutex");
		goto fail;
	}

	return scene;

fail:
	pthread_mutexattr_destroy(&attr);
	bfree(scene);
	return NULL;
}

    poster(Blink * _blink, bool & ok)
      : state(WAIT), blink(_blink)
    {
      pthread_mutexattr_t attr;
      pthread_mutexattr_init(&attr);
      pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_ERRORCHECK);
      pthread_mutex_init(&mutex, &attr);
      pthread_mutexattr_destroy(&attr);
      switch(pthread_create(&thread_id, 0, run, this)){
      case EAGAIN:
	if(0 != blink->m_os)
	  (*blink->m_os) << "insufficient resources for thread.\n";
	ok = false;
	break;
      case EINVAL:
	if(0 != blink->m_os)
	  (*blink->m_os) << "BUG [invalid attr for pthread_create()]\n";
	ok = false;
	break;
      default:
	ok = true;
      }
    }

/*---------------------------------------------------------------------------------*/
void engine::finalize(){
  if ( runMultiThread ) {
    pthread_mutex_destroy(&thread_lock);
    pthread_mutexattr_destroy(&mutex_attr);
    task_submission_finished=true;
    LOG_INFO(LOG_MULTI_THREAD,"before join\n");
    if ( thread_model  >=1){
      pthread_join(mbsend_tid,NULL);
      LOG_INFO(LOG_MULTI_THREAD," MBSend thread joined\n");
    }
    if ( thread_model  >=2){
      pthread_join(mbrecv_tid,NULL);
      LOG_INFO(LOG_MULTI_THREAD,"MBRecv thread joined\n");
    }
    pthread_join(thread_id,NULL);
    LOG_INFO(LOG_MULTI_THREAD,"Admin thread joined\n");
  }
  else
    doProcessLoop((void *)this);
  globalSync();
  if(cfg->getDLB())
    dlb.dumpDLB();
}

	DeckLinkConsumer()
	{
		pthread_mutexattr_t mta;

		m_displayMode = NULL;
		m_deckLinkKeyer = NULL;
		m_deckLinkOutput = NULL;
		m_deckLink = NULL;

		m_aqueue = mlt_deque_init();
		m_frames = mlt_deque_init();

		// operation locks
		m_op_id = OP_NONE;
		m_op_arg = 0;
		pthread_mutexattr_init( &mta );
		pthread_mutexattr_settype( &mta, PTHREAD_MUTEX_RECURSIVE );
		pthread_mutex_init( &m_op_lock, &mta );
		pthread_mutex_init( &m_op_arg_mutex, &mta );
		pthread_mutexattr_destroy( &mta );
		pthread_cond_init( &m_op_arg_cond, NULL );
		pthread_create( &m_op_thread, NULL, op_main, this );
	}

int myfunc() {
	int ret = 0;
	int type = 0;
	pthread_mutexattr_t attr;
	if ((ret = pthread_mutexattr_init(&attr)) != 0)
	{
		printf("pthread_mutexattr_init error: %s\n", strerror(ret));       
		return ret; 
	}
	if ((ret = pthread_mutexattr_gettype(&attr, &type)) != 0)
	{
		printf("gettype error\n");
		return ret;
	}
	whichtype(type);

	if ((ret = pthread_mutexattr_destroy(&attr)) != 0)
	{
		printf("destroy error\n");
		return ret;
	}
    return 0;
}

//建立临界区
void MThreadBase::rv_CreateSection()
{
	if(s_blSectionFlag)
		return;
	#ifndef LINUXCODE
		::InitializeCriticalSection(&s_stSection);
	#else	
		/*
		 *	GUOGUO 2009-08-11 设置临界区锁的属性为可递归锁,支持同一线程连续调用lock
		 */
		//	ADD
		pthread_mutexattr_t attr;
		pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE_NP);
		//	ADD END

		pthread_mutex_init(&s_stSection,&attr);

		//	ADD
		pthread_mutexattr_destroy(&attr);
		//	ADD END
	#endif
	s_blSectionFlag = true;
}

MessageQueue::MessageQueue( int maxMessages_ ) :
	shutdown( false ),
	maxMessages( maxMessages_ ),
	messages( new message_t[ maxMessages_ ] ),
	head( 0 ),
	tail( 0 )
{
	assert( maxMessages > 0 );

	for ( int i = 0; i < maxMessages; i++ )
	{
		messages[i].string = NULL;
		messages[i].synced = false;
	}

	pthread_mutexattr_t	attr;
	pthread_mutexattr_init( &attr );
	pthread_mutexattr_settype( &attr, PTHREAD_MUTEX_ERRORCHECK );
	pthread_mutex_init( &mutex, &attr );
	pthread_mutexattr_destroy( &attr );
	pthread_cond_init( &posted, NULL );
	pthread_cond_init( &received, NULL );
}

/*****************************************************************************
 * vlc_mutex_init: initialize a recursive mutex (Do not use)
 *****************************************************************************/
int vlc_mutex_init_recursive( vlc_mutex_t *p_mutex )
{
#if defined( LIBVLC_USE_PTHREAD )
    pthread_mutexattr_t attr;
    int                 i_result;

    pthread_mutexattr_init( &attr );
#  if defined (__GLIBC__) && (__GLIBC_MINOR__ < 6)
    pthread_mutexattr_setkind_np( &attr, PTHREAD_MUTEX_RECURSIVE_NP );
#  else
    pthread_mutexattr_settype( &attr, PTHREAD_MUTEX_RECURSIVE );
#  endif
    i_result = pthread_mutex_init( p_mutex, &attr );
    pthread_mutexattr_destroy( &attr );
    return( i_result );
#elif defined( WIN32 )
    /* Create mutex returns a recursive mutex */
    *p_mutex = CreateMutex( 0, FALSE, 0 );
    return (*p_mutex != NULL) ? 0 : ENOMEM;
#else
# error Unimplemented!
#endif
}