xtd 0.2.0
Loading...
Searching...
No Matches
xtd::threading::timeout Class Reference
Inheritance diagram for xtd::threading::timeout:
xtd::static_object

Definition

Contains a constant used to specify an infinite amount of time. This class cannot be inherited.

Contains a constant used to specify an infinite amount of time. This class cannot be inherited.
Definition timeout.h:33
#define static_
This keyword is use to represent a static object. A static object can't be instantiated (constructors...
Definition static.h:37
#define core_export_
Define shared library export.
Definition core_export.h:13
Inheritance
xtd::static_objectxtd::threading::timeout
Header
#include <xtd/threading/timeout>
Namespace
xtd::threading
Library
xtd.core
Example
The following example shows a thread going to sleep for an infinite time and subsequently being woken up. As the xtd::threading::thread::interrupt method only works on the Windows operating system, on other platforms the result may be different.
#include <xtd/threading/interlocked>
#include <xtd/threading/thread>
#include <xtd/threading/thread_interrupted_exception>
#include <xtd/console>
#include <xtd/startup>
using namespace xtd;
using namespace xtd::threading;
namespace timeout_example {
class stay_awake {
public:
stay_awake() = default;
void sleep_switch(bool value) {
sleep_switch_ = value;
}
void thread_method() {
console::write_line("new_thread is executing thread_method.");
while(!sleep_switch_) {
// Use SpinWait instead of Sleep to demonstrate the
// effect of calling Interrupt on a running thread.
thread::spin_wait(10000000);
}
try {
console::write_line("new_thread going to sleep.");
// When new_thread goes to sleep, it is immediately
// woken up by a ThreadInterruptedException.
thread::sleep(timeout::infinite);
} catch(const thread_interrupted_exception& e) {
console::write_line("new_thread cannot go to sleep - "
"interrupted by main thread.");
}
}
private:
bool sleep_switch_ = false;
};
class thread_interrupt {
public:
static void main() {
auto stay_awake = timeout_example::stay_awake {};
auto new_thread = thread {thread_start {stay_awake, &timeout_example::stay_awake::thread_method}};
new_thread.start();
thread::sleep(10);
// The following line causes an exception to be thrown
// in thread_method if new_thread is currently blocked
// or becomes blocked in the future.
// This method only work on Windows Operating System.
new_thread.interrupt();
console::write_line("main thread calls interrupt on new_thread.");
// Tell new_thread to go to sleep.
stay_awake.sleep_switch(true);
// Wait for new_thread to end.
new_thread.join();
}
};
}
startup_(timeout_example::thread_interrupt::main);
// This example produces output similar to the following on Windows Operating System only:
//
// new_thread is executing thread_method.
// main thread calls interrupt on new_thread.
// new_thread going to sleep.
// new_thread cannot go to sleep - interrupted by main thread.
The exception that is thrown when a Thread is interrupted while it is in a waiting state.
Definition thread_interrupted_exception.h:25
Creates and controls a thread, sets its priority, and gets its status.
Definition thread.h:43
void start()
Causes the operating system to change the state of the current instance to xtd::threading::thread_sta...
#define startup_(main_method)
Defines the entry point to be called when the application loads. Generally this is set either to the ...
Definition startup.h:175
delegate< void()> thread_start
Represents the method that executes on a xtd::threading::thread.
Definition thread_start.h:24
The xtd::threading namespace provides classes and interfaces that enable multithreaded programming....
Definition abandoned_mutex_exception.h:11
The xtd namespace contains all fundamental classes to access Hardware, Os, System,...
Definition xtd_about_box.h:10

Public Fields

static constexpr int32 infinite
 A constant used to specify an infinite waiting period. This field is constant.
 
static const time_span infinite_time_span
 A constant used to specify an infinite waiting period, for methods that accept a TimeSpan parameter.
 

Member Data Documentation

◆ infinite

constexpr int32 xtd::threading::timeout::infinite
staticconstexpr

A constant used to specify an infinite waiting period. This field is constant.

Remarks
The value of this constant is -1. For threading methods that accept a timeout parameter, such as Thread::Sleep(int32) and Thread::Join(int32), this value is used to suppress timeout behavior.
The value of this field is -1 (0xFFFFFFFF).

◆ infinite_time_span

const time_span xtd::threading::timeout::infinite_time_span
static

A constant used to specify an infinite waiting period, for methods that accept a TimeSpan parameter.

Remarks
For threading methods that accept a timeout parameter of type TimeSpan, such as Thread.Sleep(TimeSpan) and Thread.Join(TimeSpan), this value is used to suspend the thread indefinitely. However, in most cases, we recommend that you use other System.Threading classes such as Mutex, Monitor, EventWaitHandle, or Semaphore instead to sychronize threads or manage resources.
The value of this field is -00:00:00.0010000, or -1 millisecond.

The documentation for this class was generated from the following file: