void thread_function_increase_timemutex()
{
for (int i=0; i<5; i++)
{
if(g_counter_time_mutex.try_lock_for(std::chrono::seconds(1)))
//g_counter_mutex.lock();
{
++g_counter;
cout << this_thread::get_id() << ": " << i << endl;
g_counter_time_mutex.unlock();
this_thread::sleep_for(std::chrono::seconds(2));
}
}
}
void execute_usb_command(uvc::device & device, std::timed_mutex & mutex, unsigned char handle_id, uint8_t *out, size_t outSize, uint32_t & op, uint8_t * in, size_t & inSize)
{
// write
errno = 0;
int outXfer;
if (!mutex.try_lock_for(std::chrono::milliseconds(IVCAM_MONITOR_MUTEX_TIMEOUT))) throw std::runtime_error("timed_mutex::try_lock_for(...) timed out");
std::lock_guard<std::timed_mutex> guard(mutex, std::adopt_lock);
bulk_transfer(device, handle_id, IVCAM_MONITOR_ENDPOINT_OUT, out, (int)outSize, &outXfer, 1000); // timeout in ms
std::this_thread::sleep_for(std::chrono::milliseconds(20));
// read
if (in && inSize)
{
uint8_t buf[IVCAM_MONITOR_MAX_BUFFER_SIZE];
errno = 0;
bulk_transfer(device, handle_id, IVCAM_MONITOR_ENDPOINT_IN, buf, sizeof(buf), &outXfer, 1000);
if (outXfer < (int)sizeof(uint32_t)) throw std::runtime_error("incomplete bulk usb transfer");
op = *(uint32_t *)buf;
if (outXfer > (int)inSize) throw std::runtime_error("bulk transfer failed - user buffer too small");
inSize = outXfer;
memcpy(in, buf, inSize);
}
}
void bulk_usb_command(uvc::device & device, std::timed_mutex & mutex, unsigned char out_ep, uint8_t *out, size_t outSize, uint32_t & op, unsigned char in_ep, uint8_t * in, size_t & inSize, int timeout)
{
// write
errno = 0;
int outXfer;
if (!mutex.try_lock_for(std::chrono::milliseconds(timeout))) throw std::runtime_error("timed_mutex::try_lock_for(...) timed out");
std::lock_guard<std::timed_mutex> guard(mutex, std::adopt_lock);
bulk_transfer(device, out_ep, out, (int)outSize, &outXfer, timeout); // timeout in ms
// read
if (in && inSize)
{
uint8_t buf[1024]; // TBD the size may vary
errno = 0;
bulk_transfer(device, in_ep, buf, sizeof(buf), &outXfer, timeout);
if (outXfer < (int)sizeof(uint32_t)) throw std::runtime_error("incomplete bulk usb transfer");
op = *(uint32_t *)buf;
if (outXfer > (int)inSize) throw std::runtime_error("bulk transfer failed - user buffer too small");
inSize = outXfer;
memcpy(in, buf, inSize);
}
}
void lock()
{
using namespace std::chrono;
if (_m.try_lock())
return;
detail::threading_primitive_guard g;
if (g.should_detect_deadlocks())
{
auto d = milliseconds(TimeoutMs_);
detail::timer t;
while (!_m.try_lock_for(d))
LoggerPolicy_::show_message(detail::make_log_message("Could not lock mutex", get_id(), t.elapsed()));
}
else
_m.lock();
}
void test(const std::string& threadName){
std::chrono::milliseconds timeout(100);
for(int i = 0; i < 10; ++i){
// Give up trying to acquire the lock after a period of time.
if(timeLock.try_lock_for(timeout)){
std::cout << threadName << " - locked mutex." << std::endl;
std::chrono::milliseconds sleepDuration(500);
std::this_thread::sleep_for(sleepDuration);
timeLock.unlock();
} else {
std::cout << threadName << " - failed to lock mutex." << std::endl;
std::chrono::milliseconds sleepDuration(250);
std::this_thread::sleep_for(sleepDuration);
}
}
}
void f1()
{
time_point t0 = Clock::now();
assert(m.try_lock_until(Clock::now() + ms(300)) == true);
time_point t1 = Clock::now();
m.unlock();
ns d = t1 - t0 - ms(250);
assert(d < ms(50)); // within 50ms
}
void fireworks () {
// waiting to get a lock: each thread prints "-" every 200ms:
while (!mtx.try_lock_for(std::chrono::milliseconds(200))) {
std::cout << "-";
}
// got a lock! - wait for 1s, then this thread prints "*"
std::this_thread::sleep_for(std::chrono::milliseconds(1000));
std::cout << "*\n";
mtx.unlock();
}
static int f1()
{
time_point t0 = Clock::now();
TC_ASSERT_EXPR(m.try_lock_until(Clock::now() + ms(300)) == true);
time_point t1 = Clock::now();
m.unlock();
ns d = t1 - t0 - ms(250);
TC_ASSERT_EXPR(d < ms(50)); // within 50ms
return 0;
}
/**
* main thread that locks the mutex, starts thread then unlocks the mutex after
* 2 seconds. That allows child thread to lock the mutex.
* */
int main()
{
mutex.lock();
LOG(" M mutex locked");
std::thread t(f);
sleep(2);
mutex.unlock();
LOG(" M mutex unlocked");
sleep(2);
t.join();
return 0;
}
void f2()
{
time_point t0 = Clock::now();
assert(m.try_lock_until(Clock::now() + ms(250)) == false);
time_point t1 = Clock::now();
ns d = t1 - t0 - ms(250);
assert(d < ms(50)); // within 50ms
}
int main()
{
{
m.lock();
std::thread t(f1);
std::this_thread::sleep_for(ms(250));
m.unlock();
t.join();
}
{
m.lock();
std::thread t(f2);
std::this_thread::sleep_for(ms(300));
m.unlock();
t.join();
}
}
int tc_libcxx_thread_thread_timedmutex_class_try_lock_until(void)
{
{
m.lock();
std::thread t(f1);
std::this_thread::sleep_for(ms(250));
m.unlock();
t.join();
}
{
m.lock();
std::thread t(f2);
std::this_thread::sleep_for(ms(300));
m.unlock();
t.join();
}
TC_SUCCESS_RESULT();
return 0;
}
int main(int, char**)
{
{
m.lock();
std::thread t(f1);
std::this_thread::sleep_for(ms(250));
m.unlock();
t.join();
}
{
m.lock();
std::thread t(f2);
std::this_thread::sleep_for(ms(300));
m.unlock();
t.join();
}
return 0;
}
void fireworks() {
// 这边未什么用while呢？因为没获得锁的时候不能往下走调用unlock会引发abort
if (!mtimetx.try_lock_for(std::chrono::milliseconds(200))) {
std::cout << "草，没有获得锁" << endl;
}
std::cout << "获得锁!!!!!!!" << endl;
std::this_thread::sleep_for(std::chrono::milliseconds(1000));
std::cout << "*\n";
//mtimetx.unlock();
}
void work(){
std::chrono::milliseconds timeout(100);
while(true){
if(mutex.try_lock_for(timeout)){
std::cout << std::this_thread::get_id() << ": do work with the mutex" << std::endl;
std::chrono::milliseconds sleepDuration(250);
std::this_thread::sleep_for(sleepDuration);
mutex.unlock();
std::this_thread::sleep_for(sleepDuration);
} else {
std::cout << std::this_thread::get_id() << ": do work without mutex" << std::endl;
std::chrono::milliseconds sleepDuration(100);
std::this_thread::sleep_for(sleepDuration);
}
}
}
void unlock()
{ _m.unlock(); }
bool try_lock()
{ return _m.try_lock(); }
namespace node_ios_device {
const double notificationWait = 0.5;
CFMutableDictionaryRef connectedDevices;
std::mutex deviceMutex;
CFRunLoopRef runloop;
std::timed_mutex initMutex;
static bool initialized = false;
static am_device_notification deviceNotification = NULL;
static CFRunLoopTimerRef initTimer;
static void stopInitTimer() {
if (initTimer) {
debug("Removing init timer from run loop");
::CFRunLoopTimerInvalidate(initTimer);
::CFRunLoopRemoveTimer(runloop, initTimer, kCFRunLoopCommonModes);
::CFRelease(initTimer);
initTimer = NULL;
}
}
static void unlockInitMutex(CFRunLoopTimerRef timer, void* info) {
initialized = true;
initMutex.unlock();
stopInitTimer();
}
static void createInitTimer() {
// set a timer for 250ms to unlock the initMutex
CFRunLoopTimerContext timerContext = { 0, NULL, NULL, NULL, NULL };
initTimer = ::CFRunLoopTimerCreate(
kCFAllocatorDefault, // allocator
CFAbsoluteTimeGetCurrent() + notificationWait, // fireDate
0, // interval
0, // flags
0, // order
unlockInitMutex,
&timerContext
);
debug("Adding init timer to run loop");
::CFRunLoopAddTimer(runloop, initTimer, kCFRunLoopCommonModes);
}
/**
* The callback when a device notification is received.
*/
static void on_device_notification(am_device_notification_callback_info* info, void* arg) {
bool changed = false;
debug("Resetting timer due to new device notification");
stopInitTimer();
// ensure that the device is connected via USB
if (::AMDeviceGetInterfaceType(info->dev) == 1) {
if (info->msg == ADNCI_MSG_CONNECTED) {
std::lock_guard<std::mutex> lock(deviceMutex);
node_ios_device::Device* device = new node_ios_device::Device(info->dev);
if (!::CFDictionaryContainsKey(connectedDevices, device->udid)) {
node_ios_device::debug("Device connected");
try {
device->init();
// if we already have the device info, don't get it again
if (device->loaded && !::CFDictionaryContainsKey(connectedDevices, device->udid)) {
::CFDictionarySetValue(connectedDevices, device->udid, device);
changed = true;
}
} catch (...) {
node_ios_device::debug("Failed to init device");
delete device;
}
}
} else if (info->msg == ADNCI_MSG_DISCONNECTED) {
std::lock_guard<std::mutex> lock(deviceMutex);
CFStringRef udid = ::AMDeviceCopyDeviceIdentifier(info->dev);
if (::CFDictionaryContainsKey(connectedDevices, udid)) {
// remove the device from the dictionary and destroy it
node_ios_device::Device* device = (node_ios_device::Device*)::CFDictionaryGetValue(connectedDevices, udid);
::CFDictionaryRemoveValue(connectedDevices, udid);
node_ios_device::debug("Device disconnected: %s", device->props["udid"].c_str());
delete device;
changed = true;
}
}
}
if (!initialized) {
createInitTimer();
}
// we need to notify if devices changed and this must be done outside the
// scopes above so that the mutex is unlocked
if (changed) {
node_ios_device::send("devicesChanged");
}
}
/**
* Starts the run loop.
*/
void startRunLoop() {
connectedDevices = ::CFDictionaryCreateMutable(NULL, 0, &kCFTypeDictionaryKeyCallBacks, NULL);
node_ios_device::debug("Subscribing to device notifications");
::AMDeviceNotificationSubscribe(&on_device_notification, 0, 0, NULL, &deviceNotification);
runloop = ::CFRunLoopGetCurrent();
createInitTimer();
node_ios_device::debug("Starting CoreFoundation run loop");
::CFRunLoopRun();
}
/**
* Stops the run loop.
*/
void stopRunLoop() {
// free up connected devices
CFIndex size = ::CFDictionaryGetCount(connectedDevices);
CFStringRef* keys = (CFStringRef*)::malloc(size * sizeof(CFStringRef));
::CFDictionaryGetKeysAndValues(connectedDevices, (const void **)keys, NULL);
CFIndex i = 0;
for (; i < size; i++) {
Device* device = (Device*)::CFDictionaryGetValue(connectedDevices, keys[i]);
::CFDictionaryRemoveValue(connectedDevices, keys[i]);
delete device;
}
::free(keys);
::CFRelease(connectedDevices);
::AMDeviceNotificationUnsubscribe(deviceNotification);
stopInitTimer();
::CFRunLoopStop(runloop);
}
} // end namespace node_ios_device
static void unlockInitMutex(CFRunLoopTimerRef timer, void* info) {
initialized = true;
initMutex.unlock();
stopInitTimer();
}