Wikibooks zhwikibooks https://zh.wikibooks.org/wiki/Wikibooks:%E9%A6%96%E9%A1%B5 MediaWiki 1.39.0-wmf.26 first-letter Media Special Talk User User talk Wikibooks Wikibooks talk File File talk MediaWiki MediaWiki talk Template Template talk Help Help talk Category Category talk Transwiki Transwiki talk Wikijunior Wikijunior talk Subject Subject talk TimedText TimedText talk Module Module talk Gadget Gadget talk Gadget definition Gadget definition talk 0 13231 168533 168343 2022-08-25T06:31:05Z Paho.mqtt 60409 wikitext text/x-wiki {{noteTA| G1=IT }} __NOTOC__ __NOEDITSECTION__ -{H|zh-cn:算法;zh-tw:演算法}--{H|zh-cn:参数;zh-tw:引數}--{H|zh-cn:数组;zh-tw:陣列}--{H|zh-cn:数据;zh-tw:資料}--{H|zh-cn:调试;zh-tw:除錯}--{H|zh-cn:变量;zh-tw:變數}--{H|zh-cn:程序;zh-tw:程式}--{H|zh-cn:过程;zh-tw:程序}--{H|zh-cn:指针;zh-tw:指標}--{H|zh-cn:分支;zh-tw:分歧}--{H|zh-cn:运算符重载;zh-tw:運算子多載}--{H|zh-cn:;zh-tw:}- <div align="center" style="font-size: 400%;">'''C++ 编程'''</div> ===[[/序/]]{{stage short|100%|2011-4-27}}=== === [[/起步|起步]]{{stage short|25%|2016年7月7日 (四) 14:16 (UTC)}} === ※非必要，如果要學習程式設計並不需要知道其歷史。 * [[C++/歷史|歷史]]{{stage short|00%|25 March 2007}} * [[C++/與其他語言比較|與其他語言比較]]{{stage short|00%|25 March 2007}} * [[C++/常用编译器|常用编译器]] === 基础 === * [[C++/資料輸入輸出|資料輸入輸出]]{{stage short|15%|UTC+8 2019-01-20 21:09}} * [[C++/變數及資料型態|變數及資料型態入门]]{{stage short|50%|UTC+8 2018-12-30 12:20}} * [[C++/变量|关于变量的深入知识]] * [[C++/陣列|陣列]]{{stage short|98%|UTC+8 2018-12-30 12:20}} * [[C++/指標與參考|指標與參考]]{{stage short|00%|25 March 2007}} * [[C++/條件分歧|條件分歧]]{{stage short|00%|25 March 2007}} * [[C++/迴圈|迴圈]]{{stage short|00%|25 March 2007}} * [[C++/函數|函數]]{{stage short|00%|25 March 2007}} * 名字的[[C++/作用域|作用域]] * [[:w:命名空间#C++中的名字空间|名字空间（命名空间）]] === 面向对象编程 === * [[C++/類|類]]{{stage short|00%|25 March 2007}} * [[C++/建構子|建構子]]{{stage short|00%|25 March 2007}} * [[C++/運算子多載|運算子多載]]{{stage short|00%|25 March 2007}} * [[C++/繼承|繼承]]{{stage short|00%|25 March 2007}} * [[C++/虛擬函數|虛擬函數]]{{stage short|00%|25 March 2007}} === 高级特性 === * [[C++/例外處理|例外處理]]{{stage short|00%|25 March 2007}} * [[C++/模板|模板]]{{stage short|00%|25 March 2007}} **[[C++/元函数|元函数]] * [[C++/型態轉換|型態轉換]]{{stage short|00%|25 March 2007}} * [[C++/前置處理|前置處理]]{{stage short|00%|25 March 2007}} * [[C++/特性|特性]] （从C++11开始） ===[[:w:C++标准函式库|标准库]]=== * [[C++/STL/any|any]] * [[C++/STL/Algorithm|Algorithm]] ‎ * [[C++/STL/Array|Array]] ‎ * [[C++/Atomic|Atomic]] ‎ * [[C++/Bitset|Bitset]] * [[C++/charconv|charconv]] * [[C++/STL/Chrono|Chrono]] * [[C++/codecvt|codecvt]] ‎ ([[:w:C++17|C++17]]语言标准中过时) * [[C++/complex|complex]] * [[C++/STL/ConditionVariable|ConditionVariable]] * [[C++/STL/Deque|Deque]] * [[C++/exception|exception]] * [[C++/STL/execution|execution]] * [[C++/STL/filesystem|filesystem]] * [[C++/STL/forward_list|Forward list]] * [[C++/Fstream|Fstream]] * [[C++/functional|functional]] * [[C++/STL/Future|Future]] ‎ * [[C++/Initializer list|initializer_list]] ‎ * [[C++/iomanip|iomanip]] * [[C++/ios|ios]] * [[C++/iosfwd|iosfwd]] * [[C++/iostream|iostream]] * [[C++/istream|istream]] * [[C++/STL/Iterator|Iterator]] ‎ * [[C++/limits|limits]] * [[:w:List (STL)|List]] * [[C++/Locale|Locale]] * [[C++/map|map]] * [[:w:memory (C++标准库)|memory]] * [[C++/memory_resource|memory_resource]] * [[C++/multimap|multimap]] * [[C++/multiset|multiset]] * [[C++/Mutex|Mutex]] ‎ * [[:w:new (C++标准库)|new]] * [[C++/Numeric|Numeric]] * [[C++/STL/optional|optional]] * [[C++/ostream|ostream]] * [[C++/queue|queue]] * [[C++/random|random]] * [[C++/ratio|ratio]] * [[C++/Regex|Regex]] ‎ * [[C++/scoped_allocator|scoped_allocator]] * [[C++/set|set]] * [[C++/shared_mutex|shared_mutex]] * [[C++/stack|stack]] * [[C++/stdexcept|stdexcept]] * [[C++/sstream|sstream]] * [[C++/Streambuf|Streambuf]] ‎ * [[:w:String_(C%2B%2B标准库)|string]] ‎ * [[C++/string_view|string_view]] * [[C++/system_error|system_error]] * [[C++/STL/Thread|Thread]] ‎ * [[C++/Tuple|Tuple]] * [[C++/STL/type_index|type_index]] * [[C++/Typeinfo|Typeinfo]] * [[C++/STL/type_traits|type_traits]] * [[:w:unordered_map (STL)|unordered_map]] * [[:w:unordered_map (STL)|unordered_multimap]] * [[:w:unordered_set (STL)|unordered_set]] * [[:w:unordered_set (STL)|unordered_multiset]] * [[C++/Utility|Utility]] * [[C++/STL/valarray|valarray]] * [[C++/STL/variant|variant]] * [[:w:Vector (STL)|vector]] === [[/非标准内容|非标准内容]]{{stage short|00%|25 March 2007}} (在現實世界) === === 附錄A: 參照表格 <small>(運用在書中)</small> === === 附錄B: [[C++/外部參照|外部參照]]{{stage short|00%|25 March 2007}} <small>(運用在書中)</small> === === 附錄C: [[/範例|程式碼範例]]{{stage short|00%|25 March 2007}} <small>(運用在書中)</small> === === 附錄D: 練習 === <big><center>[[/編輯的TOC|編輯的TOC >>]]</center></big> {{stages}} [[Category:C++]] [[Category:C++ Programming|C++ Programming]] [[Category:编程语言]] [[ja:More C++ Idioms]] pq9wp35wjygsvs3h4b4one0u7nw7675 0 22440 168535 133865 2022-08-25T06:45:59Z Paho.mqtt 60409 wikitext text/x-wiki '''condition_variable''' 是[[w:C++標準程式庫|標準程式庫]]中的一個[[w:头文件|头文件]]，定义了[[w:C++11|C++11]]标准中的一些用于[[w:并发计算|并发编程]]时表示[[w:条件变量|条件变量]]的类与方法等。从[[w:g++|g++]] 4.8.1、[[w:Visual C++|Visual C++]] 2012都已经支持了C++11标准中定义的condition_variable头文件。 ==背景简介== [[w:条件变量|条件变量]]是[[w:并发程序|并发程序设计]]中的一种控制结构。多个[[w:线程|线程]]访问一个共享资源（或称[[w:临界区|临界区]]）时，不但需要用[[w:互斥锁|互斥锁]]实现独享访问以避免并发错误（称为[[w:竞争危害|竞争危害]]），在获得互斥锁进入临界区后还需要检验特定条件是否成立： *如果不满足该条件，拥有互诉锁的线程应该释放该互斥锁、把自身阻塞（block）并挂到（suspend）条件变量的线程队列中； *如果满足该条件，拥有互诉锁的线程在临界区内访问共享资源，在退出临界区时通知（notify）在条件变量的线程队列中处于阻塞状态的线程，被通知的线程必须重新申请对该互斥锁加锁。 如上，实际上使用了两个处于阻塞状态的线程的队列，分别为条件变量与互斥锁所拥有。 [[w:C++11|C++11]]的标准库中新增加的条件变量的实现，与[[w:pthread|pthread]]的实现语义完全一致。 使用条件变量做并发控制时，某一时刻阻塞在一个条件变量上的各个线程应该在调用wait操作时指明同一个互斥锁，此时该条件变量与该互斥锁绑定；否则程序的行为未定义。条件变量必须与互斥锁配合使用，其理由是程序需要判定某个条件（condition或称predict）是否成立，该条件可以是任意复杂。通行的编程样例为（[[w:伪代码|伪代码]]）： mutex.lock();//互斥锁加锁 while（predict()!=true) // predict可以任意复杂，但必须互斥独占访问 conditionVariable.wait(); //退出while循环执行至此时，既有predict()为真且获得了mutex加锁 离开临界区的线程用notify操作解除阻塞（unblock）在条件变量上的各个线程时，按照公平性（fairness）这些线程应该有平等的获得互斥锁的机会，不应让某个线程始终难以获得互斥锁被饿死（starvation），并且比后来到临界区的其它线程更为优先（即基本上FIFO）。一种办法是调用了notify_all的线程保持互斥锁，直到所有从条件变量上解除阻塞的线程都已经挂起（suspend）到互斥锁上，然后发起了notify_all的线程再释放互斥锁。<ref>[http://www.cs.wustl.edu/~schmidt/win32-cv-1.html Douglas C. Schmidt and Irfan Pyarali：《Strategies for Implementing POSIX Condition Variables on Win32》&sect;3.4. The SignalObjectAndWait Solution]</ref>互斥锁上一般都有比较完善的阻塞线程调度算法，一般会按照线程优先级调度，相同优先级按照FIFO调度。 发起notify的线程不需要拥有互斥锁。 即将离开临界区的线程是先释放互斥锁还是先notify操作解除在条件变量上挂起线程的阻塞？表面看两种顺序都可以。但一般建议是先notify操作，后对互斥锁解锁。因为这既有利于上述的公平性，同时还避免了相反顺序时可能的[[w:优先级倒置]]。这种先notify后解锁的做法是悲观的（pessimization），因为被通知（notified）线程将立即被阻塞，等待通知（notifying）线程释放互斥锁。很多实现（特别是pthreads的很多实现）为了避免这种“匆忙与等待”（hurry up and wait）情形，把在条件变量的线程队列上处于等待的被通知线程直接移到互斥锁的线程队列上，而不唤醒这些线程。 ==std::condition_variable类== std::condition_variable类表示[[w:条件变量]]。效果上相当于包装了[[w:pthread]]库中的pthread_cond_*()系列的函数。 *构造函数 **condition_variable();缺省构造函数 **condition_variable (const condition_variable&) = delete;禁止拷贝构造函数 *成员函数 **void wait (unique_lock<mutex>& lck); 无条件被阻塞。调用该函数前，当前线程应该已经对unique_lock<mutex> lck完成了加锁。所有使用同一个条件变量的线程必须在wait函数中使用同一个unique_lock<mutex>。该wait函数内部会自动调用lck.unlock()对互斥锁解锁，使得其他被阻塞在互斥锁上的线程恢复执行。使用本函数被阻塞的当前线程在获得通知(notified，通过别的线程调用 notify_*系列的函数）而被唤醒后，wait()函数恢复执行并自动调用lck.lock()对互斥锁加锁。 **template <class Predicate> void wait (unique_lock<mutex>& lck, Predicate pred);带条件的被阻塞。wait函数设置了谓词（Predicate），只有当pred条件为false时调用该wait函数才会阻塞当前线程，并且在收到其他线程的通知后只有当pred为true时才会被解除阻塞。因此，等效于<code>while (!pred()) wait(lck);</code> **template <class Rep, class Period> cv_status wait_for (unique_lock<mutex>& lck, const chrono::duration<Rep,Period>& rel_time);指定一个时间段，在当前线程收到通知（notify）或者超过指定时间段，wait_for 返回 **template <class Rep, class Period, class Predicate> bool wait_for (unique_lock<mutex>& lck, const chrono::duration<Rep,Period>& rel_time, Predicate pred); 有条件阻塞且超时返回。 **template <class Clock, class Duration> cv_status wait_until (unique_lock<mutex>& lck, const chrono::time_point<Clock,Duration>& abs_time);指定一个绝对时间点，超时wait_until返回。 **template <class Clock, class Duration, class Predicate> bool wait_until (unique_lock<mutex>& lck, const chrono::time_point<Clock,Duration>& abs_time, Predicate pred);有条件阻塞且超时返回。 **notify_one():唤醒某个等待线程，该线程是通过该条件变量的某个wait函数阻塞在该条件变量的线程队列上。如果当前没有等待线程，则该函数什么也不做 **notify_all():唤醒所有的等待(wait)线程。如果当前没有等待线程，则该函数什么也不做。 ==std::condition_variable_any类== 与std::condition_variable用法一样，区别仅在于std::condition_variable_any 的 wait 函数可以接受任何 lockable 参数，而 std::condition_variable 只能接受 std::unique_lock<std::mutex> 类型的参数。 ==std::cv_status枚举类型== *std::cv_status::no_timeout: wait_for 或者 wait_until 没有超时即返回，即在规定的时间段内线程收到了通知。 *std::cv_status::timeout: wait_for 或者 wait_until 超时后返回。 ==函数std::notify_all_at_thread_exit()== 函数原型为： void notify_all_at_thread_exit (condition_variable& cond, unique_lock<mutex> lck); 当调用该函数的线程退出时，所有在 cond 条件变量上等待的线程都会收到通知。Microsoft Visual C++ 2013已经支持了该函数；但GCC 4.9.3尚未支持该函数。 ==例子程序== <syntaxhighlight lang="cpp"> #include <iostream> #include <string> #include <thread> #include <mutex> #include <condition_variable> std::mutex m; std::condition_variable cv; std::string data; bool ready = false; bool processed = false; void worker_thread() { // 等待主线程设置好ready变量为真 std::unique_lock<std::mutex> lk(m); cv.wait(lk, []{return ready;}); //或者为 cv.wait(lk); // 现在拥有了互斥锁m，变量ready为真，已进入了临界区 std::cout << "Worker thread is processing data\n"; data += " after processing"; // Send data back to main() processed = true; std::cout << "Worker thread signals data processing completed\n"; // 手工解锁，并通知阻塞在cv上的某个线程。 cv.notify_one(); lk.unlock(); } int main() { std::thread worker(worker_thread); //启动工作线程 data = "Example data"; //把ready变量由false变为true，这使得工作线程进入临界区 { std::lock_guard<std::mutex> lk(m); //由于工作线程不可能更早得到ready为真，所以主线程很快就会获得互斥锁m ready = true; std::cout << "main() signals data ready for processing\n"; } cv.notify_one(); //通知已经阻塞在cv上的某个线程；如果没有线程被阻塞，则什么也不做 // 等待工作线程——主线程需要获得互斥锁m且processed变量变为真 { std::unique_lock<std::mutex> lk(m); cv.wait(lk, []{return processed;}); } std::cout << "Back in main(), data = " << data << '\n'; worker.join(); } </syntaxhighlight> ==示例：实现信号量== <syntaxhighlight source="cpp"> #include <mutex> #include <condition_variable> class Semaphore { public: Semaphore (int count_ = 0) : count(count_) {} inline void notify() { std::unique_lock<std::mutex> lock(mtx); count++; cv.notify_one(); } inline void wait() { std::unique_lock<std::mutex> lock(mtx); while(count == 0){ cv.wait(lock); } count--; } private: std::mutex mtx; std::condition_variable cv; int count; }; </syntaxhighlight> ==参考文献== <references/> pp70n0tuuu7tw5jyo5l61qdcvuxtqk8 0 22441 168530 141741 2022-08-25T03:00:29Z Paho.mqtt 60409 /* std::async()函数模板 */ wikitext text/x-wiki '''future''' 是[[:w:C++標準程式庫|C++標準庫]]中的一個[[:w:头文件|头文件]]，定义了[[:b:C++11|C++11]]标准中的一些表示[[:w:线程|线程]][[:w:并发控制|并发控制]]时数据共享的类与方法、数据类型，实现了“生产者”（provider）-“消费者”（consumer）并发模型的数据同步。 该头文件主要声明了： *Providers 类：std::promise, std::package_task *Futures 类：std::future, std::shared_future *Providers 函数：std::async() *其他类型：std::future_error, std::future_errc, std::future_status, std::launch. 在并发编程中，常用到一组非阻塞的模型：promise与future。future表示一个可能还没有实际完成的异步任务的结果。并发程序中的消费者使用future可以等待（wait）、超时等待（wait_for或wait_until）、获取(共享状态上设置的，许诺提供的)值（get）等操作。而promise是future的源头，任务执行者（并发程序生产者）可以设置结果值（set_value）、标记任务完成或者失败。如果promise在设置结果值之前就被摧毁了，在对应的future上阻塞的线程会得到std::broken_promise异常。这一套模型是很多异步非阻塞架构的基础。 一个std::future是一个异步返回对象（ is an asynchronous return object），它从一个共享状态读取结果。一个std::promise是一个一步提供者（asynchronous provider），该对象提供一个结果给一个共享状态。异步提供者在初始化时创建一个共享状态，一个future引用这个共享状态。异步提供者可以是std::promise、std::packaged_task、std::async内部的实现等。 ==std::promise类模板== std::promise类模板用于数据同步共享模型中的“生产者”（provider）线程提供数据。std::promise提供了一套设施可存储一个值或异常，std::promise的对象创建的std::future对象稍后可以异步获取这个值或异常。类模板promise对象与一个共享状态（通常是std::future）相关联，在这个共享状态上保存一个可能还没有求出（evaluated）的类型为T的值（可以为void）或求出为一个异常。该值可被（可能在另外一个线程中的）future对象读取，因此promise提供了一种线程数据同步的手段。promise对象是异步的数据生产者（provider），它可以在未来某一时刻设置共享状态的值。promise对共享状态可有三种操作： *make ready: promise在共享状态存储结果或异常。使状态变为ready，对与这个共享状态关联的future对象上等待（waiting）的所有线程解除阻塞（unblock）。 *release: promise放弃引用（reference to）共享状态。如果这是共享状态的最后一个引用，这将导致共享状态被摧毁。但这不适用于std::async创建的还未ready的共享状态。 *abandon: promise存储异常类型为std::future_error并具有错误码std::future_errc::broken_promise，使共享状态ready，然后再releases共享状态。 promise是promise-future通信渠道的推送端（ "push" end ）：存储一个值到共享状态会同步任何等待这个共享状态的函数（通过std::future::get）成功返回。对同一个共享状态的并发访问可能会彼此冲突：例如，std::shared_future::get的多个调用者必须或者只读或者提供外部同步机制。 *构造函数 **promise(); 缺省构造函数 **template <class Alloc> promise (allocator_arg_t aa, const Alloc& alloc); 带[[:b:分配器 (C++)|分配器]]（可省略）的构造函数 **promise (const promise&) = delete; 禁止复制构造函数 **promise (promise&& x) noexcept; 允许移动构造函数 *操作符 **禁止复制赋值操作符 **允许移动赋值操作符 *成员函数 **get_future():该函数返回一个与promise对象的共享状态相关联的future对象。返回的future对象可以访问由 promise对象设置在共享状态上的值或者某个异常对象。在调用该函数之后，promise对象通常会在某个时间点准备好一个值或者一个异常对象，此时promise对象的共享状态为ready。如果不设置值或者异常，promise对象在析构时会自动地设置一个future_error异常对象(broken_promise)来设置其自身的准备状态。 **set_value():设置promise对象的用于共享的值，此后promise对象的共享状态标志变为ready。该操作是atomic的。若无共享状态或共享状态已设置，则抛出异常std::future_error。 ***void set_value (const T& val); ***void set_value (T&& val); ***void promise<R&>::set_value (R& val); // 当promise的模板参数是引用类型(R&) ***void promise<void>::set_value (void); // 当promise的模板参数是void **set_exception():设置promise对象用于共享的异常，此后promise对象的共享状态标志变为ready. **set_value_at_thread_exit(): 设置promise对象共享状态的值，但是不将共享状态的标志设置为 ready，当线程退出时该 promise对象会自动设置为ready。注意，调用该函数后，当前线程已经设置了promise共享状态的值，如果在线程结束之前有其他设置或者修改共享状态的值的操作，则会抛出future_error(promise_already_satisfied )。 **swap():交换promise对象的共享状态。 ==std::future类模板== std::future用来获取异步任务的结果。std::future 通常由某个 Provider 创建，Provider 在某个线程中设置共享状态的值，与该共享状态相关联的 std::future 对象调用 get（通常在另外一个线程中） 获取共享状态的值。如果共享状态的标志不是ready，则该future对象所在的线程被阻塞（block），直到 Provider 设置了共享状态的值（此时共享状态的标志变为 ready）调用future::get()的线程被解除阻塞，std::future::get 返回异步任务的值或异常（如果发生了异常）。 一个有效(valid)的 std::future 对象通常由以下三种 Provider 创建，并和某个共享状态相关联： *std::async() *std::promise::get_future() *std::packaged_task::get_future() future的成员： *构造函数 **future() noexcept; **future (const future&) = delete; **future (future&& x) noexcept; *运算符 **禁止拷贝赋值 **允许移动赋值 *成员函数 **share():返回一个 std::shared_future 对象；调用该函数之后，该 std::future 对象本身已经不和任何共享状态相关联，因此该 std::future 的状态不再是 valid。 **get():当与该 std::future 对象相关联的共享状态标志变为 ready 后，调用该函数将返回保存在共享状态中的值；如果共享状态的标志不为 ready，则调用该函数会阻塞当前的调用者，而此后一旦共享状态的标志变为 ready，get 返回 Provider 所设置的共享状态的值或者异常（如果抛出了异常）。 **valid():检查当前的 std::future 对象是否有效，即是否与某个共享状态相关联。一个有效的 std::future 对象只能通过 std::async(), std::future::get_future()或者 std::packaged_task::get_future()的返回值移动构造或移动赋值。由 std::future 默认构造函数创建的 std::future 对象是无效的(invalid)。 **wait():如果共享状态的标志不是 ready，调用该成员函数会被阻塞当前线程，直到共享状态的标志变为 ready，当前线程被解除阻塞，但是 wait() 并不读取共享状态的值或者异常。 **wait_for():设置一个时间段，如果共享状态的标志在该时间段结束之前没有被 Provider 设置为 ready，则调用 wait_for 的线程被阻塞，然后在等待了该时间段的时间长度后该函数返回。返回值为future_status::ready、future_status::timeout、future_status::deferred（共享状态包含一个 deferred 函数）。 **wait_until():设置一个系统绝对时间点 abs_time，如果共享状态的标志在该时间点到来之前没有被 Provider 设置为 ready，则调用 wait_until 的线程被阻塞，在 abs_time 这一时刻到来之后 wait_for() 返回。返回值为future_status::ready、future_status::timeout、future_status::deferred。 ==std::shared_future类模板== std::shared_future 与 std::future 类似，但是 std::shared_future 可以拷贝、多个 std::shared_future 可以共享某个共享状态的值或者异常。 shared_future 可以通过某个 std::future 对象隐式转换，或者通过 std::future::share() 显示转换，无论哪种转换，被转换的那个 std::future 对象都会变为 invalid（因为std::future仅是moveable）. *构造函数 **shared_future() noexcept; **shared_future (const shared_future& x); **shared_future (shared_future&& x) noexcept; **shared_future (future<T>&& x) noexcept; *运算符 **支持move赋值 **支持拷贝赋值 *成员函数 **get(): **valid(): **wait(): **wait_for(): **wait_until(): 下述例子用于启动2个线程，在确定线程启动就绪后，同时通知多个线程，类似于std::condition_variable::notify_all()。 <syntaxhighlight lang="cpp"> #include <iostream> #include <future> #include <chrono> int main() { std::promise<void> ready_promise, t1_ready_promise, t2_ready_promise; std::shared_future<void> ready_future(ready_promise.get_future()); std::chrono::time_point<std::chrono::high_resolution_clock> start; auto fun1 = [&, ready_future]() -> std::chrono::duration<double, std::milli> { t1_ready_promise.set_value(); ready_future.wait(); // waits for the signal from main() return std::chrono::high_resolution_clock::now() - start; }; auto fun2 = [&, ready_future]() -> std::chrono::duration<double, std::milli> { t2_ready_promise.set_value(); ready_future.wait(); // waits for the signal from main() return std::chrono::high_resolution_clock::now() - start; }; auto fut1 = t1_ready_promise.get_future(); auto fut2 = t2_ready_promise.get_future(); auto result1 = std::async(std::launch::async, fun1); auto result2 = std::async(std::launch::async, fun2); // wait for the threads to become ready fut1.wait(); fut2.wait(); // the threads are ready, start the clock start = std::chrono::high_resolution_clock::now(); // signal the threads to go ready_promise.set_value(); std::cout << "Thread 1 received the signal " << result1.get().count() << " ms after start\n" << "Thread 2 received the signal " << result2.get().count() << " ms after start\n"; } </syntaxhighlight> ==std::packaged_task类模板== std::packaged_task是对promise/future的简化。可以更方便的写出异步执行的代码。 std::packaged_task实例对象为一个可执行对象、是数据的异步提供者（provider）、被包装的任务执行结束时std::packaged_task会设置共享状态的值。 std::packaged_task可用于把一些计算任务包装好，压入一个任务栈。一批线程从任务栈上取下一项并执行它。 std::packaged_task类模板包装一个可调用的对象（诸如[[:b:函数指针]]、[[:b:类成员函数指针|成员函数指针]]、[[:b:lambda表达式]]、[[:b:bind表达式]]或者[[:b:函数对象]]），该对象通常在另外一个线程中被自动执行，通过与 std::packaged_task相关联的std::future对象异步获取该可调用对象执行产生的结果。std::future对象是一个数据的异步返回对象，通过它可以获得共享状态的值，如果等待共享状态标志不为ready则调用std::future::get()的线程被挂起。std::packaged_task 的共享状态的生命周期一直持续到最后一个与之相关联的对象被释放或者销毁为止。 *构造函数 **packaged_task() noexcept;默认构造函数，初始化一个空的共享状态，并且该 packaged_task 对象无包装任务。 **template <class Fn> explicit packaged_task (Fn&& fn);初始化一个共享状态，并且被包装任务由参数 fn 指定。 **template <class Fn, class Alloc> explicit packaged_task (allocator_arg_t aa, const Alloc& alloc, Fn&& fn);带自定义内存分配器的构造函数，与默认构造函数类似，但是使用自定义分配器来分配共享状态。 **packaged_task (const packaged_task&) = delete;拷贝构造函数，被禁用。 **packaged_task (packaged_task&& x) noexcept;移动构造函数。 *运算符 **禁用了普通的赋值操作运算 **允许 move 赋值运算 **operator()(Args... args):调用该 packaged_task 对象所包装的对象(通常为函数指针，函数对象，lambda 表达式等)，传入的参数为 args. 调用该函数一般会发生两种情况： 如果成功调用 packaged_task 所包装的对象，则返回值（如果被包装的对象有返回值的话）被保存在 packaged_task 的共享状态中。 如果调用 packaged_task 所包装的对象失败，并且抛出了异常，则异常也会被保存在 packaged_task 的共享状态中。以上两种情况都使共享状态的标志变为 ready，因此其他等待该共享状态的线程可以获取共享状态的值或者异常并继续执行下去。 *成员函数 **valid():检查当前packaged_task是否和一个有效的共享状态相关联，对于由默认构造函数生成的 packaged_task 对象，该函数返回 false；除非构造后已经进行了 move 赋值操作或者 swap 操作。 **get_future():返回一个与 packaged_task 对象共享状态相关的 future 对象。返回的 future 对象可以获得别的线程在该 packaged_task 对象的共享状态上设置的某个值或者异常。 **make_ready_at_thread_exit():该函数会调用被包装的任务，并向任务传递参数，类似 std::packaged_task::operator() 成员函数。但不同的是，make_ready_at_thread_exit 并不会立即设置共享状态的标志为 ready，而是在线程退出时设置共享状态的标志。注意，该函数已经设置了 promise 共享状态的值，如果在线程结束之前有其他设置或者修改共享状态的值的操作，则会抛出 future_error( promise_already_satisfied )。 **reset():重置 packaged_task 的共享状态，但是保留之前的被包装的任务。<ref>Microsot Visual C++ 2013与GCC 4.9.3都尚未实现std::packaged_task::reset()</ref> **swap():交换 packaged_task 的共享状态。 <syntaxhighlight lang="cpp"> #include <iostream> #include <future> #include <functional> int Test_Fun(int a, int b, int& c) { //突出效果，休眠5s std::this_thread::sleep_for(std::chrono::seconds(5)); //c=233 c = a + b + 230; return c; } int main() { //声明一个std::packaged_task对象pt1，包装函数Test_Fun std::packaged_task<int(int, int, int&)> pt1(Test_Fun); //声明一个std::future对象fu1，包装Test_Fun的返回结果类型，并与pt1关联 std::future<int> fu1 = pt1.get_future(); //声明一个变量 int c = 0; //创建一个线程t1，将pt1及对应的参数放到线程里面执行 std::thread t1(std::move(pt1), 1, 2, std::ref(c)); //阻塞至线程t1结束(函数Test_Fun返回结果) int iResult = fu1.get(); std::cout << "执行结果：" << iResult << std::endl; //执行结果：233 std::cout << "c：" << c << std::endl; //c：233 t1.join(); return 1; } </syntaxhighlight> ==std::future_error类== class future_error : public logic_error; == std::async()函数模板== std::async()把一个工作负载（workload）函数作为一项任务（task）来调度执行。与std::thread()不同，std::async()由runtime来负责启动与调度。 *template <class Fn, class... Args> future<typename result_of<Fn(Args...)>::type> async(Fn&& fn, Args&&... args); *template <class Fn, class... Args> future<typename result_of<Fn(Args...)>::type> async(launch policy, Fn&& fn, Args&&... args); 第二种形式的模板函数，用第一个参数指定了启动策略， policy 参数可以是： *launch::async：完全异步执行。调用者（caller）线程与工作线程不是同一个。 *launch::deferred：工作负载函数在第一次需求获取结果时才被执行。即[[:w:惰性求值|惰性求值]]（lazy evaluation）。实际上，async()的返回值std::future对象的get()或wait()成员函数被调用时，调用者所在的线程被用来执行工作负载函数。 *上述两者的按位或，即<code>launch::async|launch::deferred</code>。这也是默认情形。这给了运行时最大的调度灵活性。但是，async()的返回值std::future对象用while循环调用wait_for将总是返回std::future_status::deferred，永远不会等于std::future_status::ready，所以while循环永远不会终止。这种bug在开发或单元测试中很容易被忽略，因为它只会在机器负载很重时才会显现。在机器过载（over subscription）或线程消耗完的状况下，任务很可能会被推迟（如果使用的是默认启动策略）。解决办法是检查std::async返回的future的wait_for函数，看返回值是否为std::future_status::deferred。 和直接使用std::thread相比，std::async有一些优势： * std::async 返回的future对象，可以方便地等待callable对象执行完成并获取其返回值 * 能从实现库的一些高级功能中获益，比如线程池等，并大大减少异常的产生。 <syntaxhighlight lang="cpp"> future<T> result = async(policy, func, this_ptr, param1); result.get(); </syntaxhighlight> 其中 *T 为返回参数类型 *para和构造普通线程的参数类似，不同的是，第一个参数可以选择launch::async、deferred或者不填，不填则默认为launch::async。 注意：std::async()总是返回一个std::future对象。如果满足下述全部条件，这个future对象析构的时就会发生阻塞： * 共享状态是通过std::async创建 * 共享状态还不是ready状态 * 被析构的future对象是共享状态的最后一个引用 可以把future对象向函数调用栈上层传播等方法，延长这个共享状态的生命期来避免这个问题。 ==定义的类型== *enum class future_errc; 该枚举类型表示std::future对象的各种情形，枚举值的意义如下： **broken_promise：与该std::future共享状态相关联的std::promise对象在设置值或者设置异常之前已被销毁。 **future_already_retrieved:与该 std::future对象相关联的共享状态的值已经被获取过了，即调用了std::future::get函数。 **promise_already_satisfied: std::promise对象已经对共享状态设置了某一值或者异常。 **no_state:无共享状态。 *enum class future_status;主要用在 std::future(或std::shared_future)中的 wait_for 和 wait_until 两个函数中 **future_status::ready:wait_for(或wait_until) 因为共享状态的标志变为 ready 而返回。 **future_status::timeout:超时，即 wait_for(或wait_until) 因为在指定的时间段（或时刻）内共享状态的标志依然没有变为 ready 而返回。 **future_status::deferred:共享状态包含了 deferred 函数。 *enum class launch;在调用 std::async 设置异步任务的启动策略 **launch::async:异步任务会在另外一个线程中调用，并通过共享状态返回异步任务的结果 **launch::deferred:异步任务将会在共享状态被访问时调用，相当与按需调用 ==例子程序== <syntaxhighlight lang="cpp"> #include <thread> #include <future> #include <cctype> #include <vector> #include <algorithm> #include <iterator> #include <iostream> #include <sstream> int main() { std::istringstream iss_numbers{"3 4 1 42 23 -23 93 2 -289 93"}; std::istringstream iss_letters{" a 23 b,e a2 k k?a;si,ksa c"}; std::vector<int> numbers; std::vector<char> letters; std::promise<void> numbers_promise, letters_promise; //std::promise<void>对象初始化后的共享状态没有ready auto numbers_ready = numbers_promise.get_future(); //std::future对象 auto letter_ready = letters_promise.get_future(); std::thread value_reader([&] //创建一个异步线程并立即开始执行 { // I/O operations. std::copy(std::istream_iterator<int>{iss_numbers}, std::istream_iterator<int>{}, std::back_inserter(numbers)); //Notify for numbers. numbers_promise.set_value(); //std::promise<void>对象numbers_promise的共享状态设置为ready std::copy_if(std::istreambuf_iterator<char>{iss_letters}, std::istreambuf_iterator<char>{}, std::back_inserter(letters), ::isalpha); //Notify for letters. letters_promise.set_value(); //std::promise<void>对象letters_promise的共享状态设置为ready }); numbers_ready.wait(); //主线程等待数值IO工作的完成 std::sort(numbers.begin(), numbers.end()); if (letter_ready.wait_for(std::chrono::seconds(1)) == //在std::future上超时等待共享状态变为ready std::future_status::timeout) { //output the numbers while letters are being obtained. for (int num : numbers) std::cout << num << ' '; numbers.clear(); //Numbers were already printed. } letter_ready.wait(); //主线程等待字母IO工作的完成 std::sort(letters.begin(), letters.end()); //If numbers were already printed, it does nothing. for (int num : numbers) std::cout << num << ' '; std::cout << '\n'; for (char let : letters) std::cout << let << ' '; std::cout << '\n'; value_reader.join(); } </syntaxhighlight> ==参考文献== <references/> jaljf5xe8wadffwswz3utahn0xmkji2 168542 168530 2022-08-25T07:27:55Z Paho.mqtt 60409 wikitext text/x-wiki '''future''' 是[[:w:C++標準程式庫|C++標準庫]]中的一個[[:w:头文件|头文件]]，定义了[[:b:C++11|C++11]]标准中的一些表示[[:w:线程|线程]][[:w:并发控制|并发控制]]时数据共享的类与方法、数据类型，实现了“生产者”（provider）-“消费者”（consumer）并发模型的数据同步。 该头文件主要声明了： *Providers 类：std::promise, std::package_task *Futures 类：std::future, std::shared_future *Providers 函数：std::async() *其他类型：std::future_error, std::future_errc, std::future_status, std::launch. 在并发编程中，常用到一组非阻塞的模型：promise与future。future表示一个可能还没有实际完成的异步任务的结果。实际上，一个std::future对象在内部分配了一个未来会赋的值的存储，并且还提供了一种访问该值的机制，即使用get()成员函数。如果通过get()函数尝试在此关联值可用之前访问该值，则get()函数将阻塞直到该值可用。并发程序中的消费者使用future可以等待（wait）、超时等待（wait_for或wait_until）、获取(共享状态上设置的，许诺提供该值（get方法）等操作。promise是future的源头，promise对象承诺将来会设置该值。任务执行者（并发程序生产者）可以设置结果值（set_value）、标记任务完成或者失败。如果promise在设置结果值之前就被摧毁了，在对应的future上阻塞的线程会得到std::broken_promise异常。这一套模型是很多异步非阻塞架构的基础。 一个std::future是一个异步返回对象（ is an asynchronous return object），它从一个共享状态读取结果。一个std::promise是一个一步提供者（asynchronous provider），该对象提供一个结果给一个共享状态。异步提供者在初始化时创建一个共享状态，一个future引用这个共享状态。异步提供者可以是std::promise、std::packaged_task、std::async内部的实现等。 ==std::promise类模板== std::promise类模板用于数据同步共享模型中的“生产者”（provider）线程提供数据。std::promise提供了一套设施可存储一个值或异常，std::promise的对象创建的std::future对象稍后可以异步获取这个值或异常。类模板promise对象与一个共享状态（通常是std::future）相关联，在这个共享状态上保存一个可能还没有求出（evaluated）的类型为T的值（可以为void）或求出为一个异常。该值可被（可能在另外一个线程中的）future对象读取，因此promise提供了一种线程数据同步的手段。promise对象是异步的数据生产者（provider），它可以在未来某一时刻设置共享状态的值。promise对共享状态可有三种操作： *make ready: promise在共享状态存储结果或异常。使状态变为ready，对与这个共享状态关联的future对象上等待（waiting）的所有线程解除阻塞（unblock）。 *release: promise放弃引用（reference to）共享状态。如果这是共享状态的最后一个引用，这将导致共享状态被摧毁。但这不适用于std::async创建的还未ready的共享状态。 *abandon: promise存储异常类型为std::future_error并具有错误码std::future_errc::broken_promise，使共享状态ready，然后再releases共享状态。 promise是promise-future通信渠道的推送端（ "push" end ）：存储一个值到共享状态会同步任何等待这个共享状态的函数（通过std::future::get）成功返回。对同一个共享状态的并发访问可能会彼此冲突：例如，std::shared_future::get的多个调用者必须或者只读或者提供外部同步机制。 *构造函数 **promise(); 缺省构造函数 **template <class Alloc> promise (allocator_arg_t aa, const Alloc& alloc); 带[[:b:分配器 (C++)|分配器]]（可省略）的构造函数 **promise (const promise&) = delete; 禁止复制构造函数 **promise (promise&& x) noexcept; 允许移动构造函数 *操作符 **禁止复制赋值操作符 **允许移动赋值操作符 *成员函数 **get_future():该函数返回一个与promise对象的共享状态相关联的future对象。返回的future对象可以访问由 promise对象设置在共享状态上的值或者某个异常对象。在调用该函数之后，promise对象通常会在某个时间点准备好一个值或者一个异常对象，此时promise对象的共享状态为ready。如果不设置值或者异常，promise对象在析构时会自动地设置一个future_error异常对象(broken_promise)来设置其自身的准备状态。 **set_value():设置promise对象的用于共享的值，此后promise对象的共享状态标志变为ready。该操作是atomic的。若无共享状态或共享状态已设置，则抛出异常std::future_error。 ***void set_value (const T& val); ***void set_value (T&& val); ***void promise<R&>::set_value (R& val); // 当promise的模板参数是引用类型(R&) ***void promise<void>::set_value (void); // 当promise的模板参数是void **set_exception():设置promise对象用于共享的异常，此后promise对象的共享状态标志变为ready. **set_value_at_thread_exit(): 设置promise对象共享状态的值，但是不将共享状态的标志设置为 ready，当线程退出时该 promise对象会自动设置为ready。注意，调用该函数后，当前线程已经设置了promise共享状态的值，如果在线程结束之前有其他设置或者修改共享状态的值的操作，则会抛出future_error(promise_already_satisfied )。 **swap():交换promise对象的共享状态。 ==std::future类模板== std::future用来获取异步任务的结果。std::future 通常由某个 Provider 创建，Provider 在某个线程中设置共享状态的值，与该共享状态相关联的 std::future 对象调用 get（通常在另外一个线程中） 获取共享状态的值。如果共享状态的标志不是ready，则该future对象所在的线程被阻塞（block），直到 Provider 设置了共享状态的值（此时共享状态的标志变为 ready）调用future::get()的线程被解除阻塞，std::future::get 返回异步任务的值或异常（如果发生了异常）。 一个有效(valid)的 std::future 对象通常由以下三种 Provider 创建，并和某个共享状态相关联： *std::async() *std::promise::get_future() *std::packaged_task::get_future() future的成员： *构造函数 **future() noexcept; **future (const future&) = delete; **future (future&& x) noexcept; *运算符 **禁止拷贝赋值 **允许移动赋值 *成员函数 **share():返回一个 std::shared_future 对象；调用该函数之后，该 std::future 对象本身已经不和任何共享状态相关联，因此该 std::future 的状态不再是 valid。 **get():当与该 std::future 对象相关联的共享状态标志变为 ready 后，调用该函数将返回保存在共享状态中的值；如果共享状态的标志不为 ready，则调用该函数会阻塞当前的调用者，而此后一旦共享状态的标志变为 ready，get 返回 Provider 所设置的共享状态的值或者异常（如果抛出了异常）。 **valid():检查当前的 std::future 对象是否有效，即是否与某个共享状态相关联。一个有效的 std::future 对象只能通过 std::async(), std::future::get_future()或者 std::packaged_task::get_future()的返回值移动构造或移动赋值。由 std::future 默认构造函数创建的 std::future 对象是无效的(invalid)。 **wait():如果共享状态的标志不是 ready，调用该成员函数会被阻塞当前线程，直到共享状态的标志变为 ready，当前线程被解除阻塞，但是 wait() 并不读取共享状态的值或者异常。 **wait_for():设置一个时间段，如果共享状态的标志在该时间段结束之前没有被 Provider 设置为 ready，则调用 wait_for 的线程被阻塞，然后在等待了该时间段的时间长度后该函数返回。返回值为future_status::ready、future_status::timeout、future_status::deferred（共享状态包含一个 deferred 函数）。 **wait_until():设置一个系统绝对时间点 abs_time，如果共享状态的标志在该时间点到来之前没有被 Provider 设置为 ready，则调用 wait_until 的线程被阻塞，在 abs_time 这一时刻到来之后 wait_for() 返回。返回值为future_status::ready、future_status::timeout、future_status::deferred。 ==std::shared_future类模板== std::shared_future 与 std::future 类似，但是 std::shared_future 可以拷贝、多个 std::shared_future 可以共享某个共享状态的值或者异常。 shared_future 可以通过某个 std::future 对象隐式转换，或者通过 std::future::share() 显示转换，无论哪种转换，被转换的那个 std::future 对象都会变为 invalid（因为std::future仅是moveable）. *构造函数 **shared_future() noexcept; **shared_future (const shared_future& x); **shared_future (shared_future&& x) noexcept; **shared_future (future<T>&& x) noexcept; *运算符 **支持move赋值 **支持拷贝赋值 *成员函数 **get(): **valid(): **wait(): **wait_for(): **wait_until(): 下述例子用于启动2个线程，在确定线程启动就绪后，同时通知多个线程，类似于std::condition_variable::notify_all()。 <syntaxhighlight lang="cpp"> #include <iostream> #include <future> #include <chrono> int main() { std::promise<void> ready_promise, t1_ready_promise, t2_ready_promise; std::shared_future<void> ready_future(ready_promise.get_future()); std::chrono::time_point<std::chrono::high_resolution_clock> start; auto fun1 = [&, ready_future]() -> std::chrono::duration<double, std::milli> { t1_ready_promise.set_value(); ready_future.wait(); // waits for the signal from main() return std::chrono::high_resolution_clock::now() - start; }; auto fun2 = [&, ready_future]() -> std::chrono::duration<double, std::milli> { t2_ready_promise.set_value(); ready_future.wait(); // waits for the signal from main() return std::chrono::high_resolution_clock::now() - start; }; auto fut1 = t1_ready_promise.get_future(); auto fut2 = t2_ready_promise.get_future(); auto result1 = std::async(std::launch::async, fun1); auto result2 = std::async(std::launch::async, fun2); // wait for the threads to become ready fut1.wait(); fut2.wait(); // the threads are ready, start the clock start = std::chrono::high_resolution_clock::now(); // signal the threads to go ready_promise.set_value(); std::cout << "Thread 1 received the signal " << result1.get().count() << " ms after start\n" << "Thread 2 received the signal " << result2.get().count() << " ms after start\n"; } </syntaxhighlight> ==std::packaged_task类模板== std::packaged_task是对promise/future的简化。可以更方便的写出异步执行的代码。 std::packaged_task实例对象为一个可执行对象、是数据的异步提供者（provider）、被包装的任务执行结束时std::packaged_task会设置共享状态的值。 std::packaged_task可用于把一些计算任务包装好，压入一个任务栈。一批线程从任务栈上取下一项并执行它。 std::packaged_task类模板包装一个可调用的对象（诸如[[:b:函数指针]]、[[:b:类成员函数指针|成员函数指针]]、[[:b:lambda表达式]]、[[:b:bind表达式]]或者[[:b:函数对象]]），该对象通常在另外一个线程中被自动执行，通过与 std::packaged_task相关联的std::future对象异步获取该可调用对象执行产生的结果。std::future对象是一个数据的异步返回对象，通过它可以获得共享状态的值，如果等待共享状态标志不为ready则调用std::future::get()的线程被挂起。std::packaged_task 的共享状态的生命周期一直持续到最后一个与之相关联的对象被释放或者销毁为止。 *构造函数 **packaged_task() noexcept;默认构造函数，初始化一个空的共享状态，并且该 packaged_task 对象无包装任务。 **template <class Fn> explicit packaged_task (Fn&& fn);初始化一个共享状态，并且被包装任务由参数 fn 指定。 **template <class Fn, class Alloc> explicit packaged_task (allocator_arg_t aa, const Alloc& alloc, Fn&& fn);带自定义内存分配器的构造函数，与默认构造函数类似，但是使用自定义分配器来分配共享状态。 **packaged_task (const packaged_task&) = delete;拷贝构造函数，被禁用。 **packaged_task (packaged_task&& x) noexcept;移动构造函数。 *运算符 **禁用了普通的赋值操作运算 **允许 move 赋值运算 **operator()(Args... args):调用该 packaged_task 对象所包装的对象(通常为函数指针，函数对象，lambda 表达式等)，传入的参数为 args. 调用该函数一般会发生两种情况： 如果成功调用 packaged_task 所包装的对象，则返回值（如果被包装的对象有返回值的话）被保存在 packaged_task 的共享状态中。 如果调用 packaged_task 所包装的对象失败，并且抛出了异常，则异常也会被保存在 packaged_task 的共享状态中。以上两种情况都使共享状态的标志变为 ready，因此其他等待该共享状态的线程可以获取共享状态的值或者异常并继续执行下去。 *成员函数 **valid():检查当前packaged_task是否和一个有效的共享状态相关联，对于由默认构造函数生成的 packaged_task 对象，该函数返回 false；除非构造后已经进行了 move 赋值操作或者 swap 操作。 **get_future():返回一个与 packaged_task 对象共享状态相关的 future 对象。返回的 future 对象可以获得别的线程在该 packaged_task 对象的共享状态上设置的某个值或者异常。 **make_ready_at_thread_exit():该函数会调用被包装的任务，并向任务传递参数，类似 std::packaged_task::operator() 成员函数。但不同的是，make_ready_at_thread_exit 并不会立即设置共享状态的标志为 ready，而是在线程退出时设置共享状态的标志。注意，该函数已经设置了 promise 共享状态的值，如果在线程结束之前有其他设置或者修改共享状态的值的操作，则会抛出 future_error( promise_already_satisfied )。 **reset():重置 packaged_task 的共享状态，但是保留之前的被包装的任务。<ref>Microsot Visual C++ 2013与GCC 4.9.3都尚未实现std::packaged_task::reset()</ref> **swap():交换 packaged_task 的共享状态。 <syntaxhighlight lang="cpp"> #include <iostream> #include <future> #include <functional> int Test_Fun(int a, int b, int& c) { //突出效果，休眠5s std::this_thread::sleep_for(std::chrono::seconds(5)); //c=233 c = a + b + 230; return c; } int main() { //声明一个std::packaged_task对象pt1，包装函数Test_Fun std::packaged_task<int(int, int, int&)> pt1(Test_Fun); //声明一个std::future对象fu1，包装Test_Fun的返回结果类型，并与pt1关联 std::future<int> fu1 = pt1.get_future(); //声明一个变量 int c = 0; //创建一个线程t1，将pt1及对应的参数放到线程里面执行 std::thread t1(std::move(pt1), 1, 2, std::ref(c)); //阻塞至线程t1结束(函数Test_Fun返回结果) int iResult = fu1.get(); std::cout << "执行结果：" << iResult << std::endl; //执行结果：233 std::cout << "c：" << c << std::endl; //c：233 t1.join(); return 1; } </syntaxhighlight> ==std::future_error类== class future_error : public logic_error; == std::async()函数模板== std::async()把一个工作负载（workload）函数作为一项任务（task）来调度执行。与std::thread()不同，std::async()由runtime来负责启动与调度。 *template <class Fn, class... Args> future<typename result_of<Fn(Args...)>::type> async(Fn&& fn, Args&&... args); *template <class Fn, class... Args> future<typename result_of<Fn(Args...)>::type> async(launch policy, Fn&& fn, Args&&... args); 第二种形式的模板函数，用第一个参数指定了启动策略， policy 参数可以是： *launch::async：完全异步执行。调用者（caller）线程与工作线程不是同一个。 *launch::deferred：工作负载函数在第一次非超时获取结果时才被执行。即[[:w:惰性求值|惰性求值]]（lazy evaluation）。实际上，async()的返回值std::future对象的get()或wait()成员函数被调用时，调用者所在的线程被用来执行工作负载函数。 *上述两者的按位或，即<code>launch::async|launch::deferred</code>。这也是默认情形。这给了运行时最大的调度灵活性。但是，async()的返回值std::future对象用while循环调用wait_for将总是返回std::future_status::deferred，永远不会等于std::future_status::ready，所以while循环永远不会终止。这种bug在开发或单元测试中很容易被忽略，因为它只会在机器负载很重时才会显现。在机器过载（over subscription）或线程消耗完的状况下，任务很可能会被推迟（如果使用的是默认启动策略）。解决办法是检查std::async返回的future的wait_for函数，看返回值是否为std::future_status::deferred。 和直接使用std::thread相比，std::async有一些优势： * std::async 返回的future对象，可以方便地等待callable对象执行完成并获取其返回值。这意味着std::async必须会合（join）。 * 能从实现库的一些高级功能中获益，比如线程池等，并大大减少异常的产生。 <syntaxhighlight lang="cpp"> future<T> result = async(policy, func, this_ptr, param1); result.get(); </syntaxhighlight> 其中 *T 为返回参数类型 *para和构造普通线程的参数类似，不同的是，第一个参数可以选择launch::async、deferred或者不填，不填则默认为launch::async。 注意：std::async()总是返回一个std::future对象。如果满足下述全部条件，这个future对象析构的时就会发生阻塞： * 共享状态是通过std::async创建 * 共享状态还不是ready状态 * 被析构的future对象是共享状态的最后一个引用 可以把future对象向函数调用栈上层传播等方法，延长这个共享状态的生命期来避免这个问题。 ==定义的类型== *enum class future_errc; 该枚举类型表示std::future对象的各种情形，枚举值的意义如下： **broken_promise：与该std::future共享状态相关联的std::promise对象在设置值或者设置异常之前已被销毁。 **future_already_retrieved:与该 std::future对象相关联的共享状态的值已经被获取过了，即调用了std::future::get函数。 **promise_already_satisfied: std::promise对象已经对共享状态设置了某一值或者异常。 **no_state:无共享状态。 *enum class future_status;主要用在 std::future(或std::shared_future)中的 wait_for 和 wait_until 两个函数中 **future_status::ready:wait_for(或wait_until) 因为共享状态的标志变为 ready 而返回。 **future_status::timeout:超时，即 wait_for(或wait_until) 因为在指定的时间段（或时刻）内共享状态的标志依然没有变为 ready 而返回。 **future_status::deferred:共享状态包含了 deferred 函数。 *enum class launch;在调用 std::async 设置异步任务的启动策略 **launch::async:异步任务会在另外一个线程中调用，并通过共享状态返回异步任务的结果 **launch::deferred:异步任务将会在共享状态被访问时调用，相当与按需调用 ==例子程序== <syntaxhighlight lang="cpp"> #include <thread> #include <future> #include <cctype> #include <vector> #include <algorithm> #include <iterator> #include <iostream> #include <sstream> int main() { std::istringstream iss_numbers{"3 4 1 42 23 -23 93 2 -289 93"}; std::istringstream iss_letters{" a 23 b,e a2 k k?a;si,ksa c"}; std::vector<int> numbers; std::vector<char> letters; std::promise<void> numbers_promise, letters_promise; //std::promise<void>对象初始化后的共享状态没有ready auto numbers_ready = numbers_promise.get_future(); //std::future对象 auto letter_ready = letters_promise.get_future(); std::thread value_reader([&] //创建一个异步线程并立即开始执行 { // I/O operations. std::copy(std::istream_iterator<int>{iss_numbers}, std::istream_iterator<int>{}, std::back_inserter(numbers)); //Notify for numbers. numbers_promise.set_value(); //std::promise<void>对象numbers_promise的共享状态设置为ready std::copy_if(std::istreambuf_iterator<char>{iss_letters}, std::istreambuf_iterator<char>{}, std::back_inserter(letters), ::isalpha); //Notify for letters. letters_promise.set_value(); //std::promise<void>对象letters_promise的共享状态设置为ready }); numbers_ready.wait(); //主线程等待数值IO工作的完成 std::sort(numbers.begin(), numbers.end()); if (letter_ready.wait_for(std::chrono::seconds(1)) == //在std::future上超时等待共享状态变为ready std::future_status::timeout) { //output the numbers while letters are being obtained. for (int num : numbers) std::cout << num << ' '; numbers.clear(); //Numbers were already printed. } letter_ready.wait(); //主线程等待字母IO工作的完成 std::sort(letters.begin(), letters.end()); //If numbers were already printed, it does nothing. for (int num : numbers) std::cout << num << ' '; std::cout << '\n'; for (char let : letters) std::cout << let << ' '; std::cout << '\n'; value_reader.join(); } </syntaxhighlight> ==参考文献== <references/> g2macq8scc2h9oic2vdx9lfawtrhjju 0 22443 168531 166486 2022-08-25T03:43:41Z Paho.mqtt 60409 wikitext text/x-wiki '''thread''' 是[[:w:C++標準程式庫]]中的一個[[:w:头文件]]，定义了[[:w:C++11]]标准中的一些表示[[:w:线程]]的类 、用于互斥访问的类与方法等。 ==线程对象thread== 类thread表示一个线程。初始化时给出该线程的执行函数（或是可以调用的对象）。线程对象构造后即开始运行。默认情况下，C++11的如此创建的线程必须与父线程会合，即在父线程中调用thread::join()函数，或者与父线程分离，即调用thread::detach()函数。否则，如果子线程还在执行，父线程已经执行结束而撤销，则会抛出异常。 如果子线程的执行函数需要参数，可把实参列表写在thread对象构造函数的参数表中。 如果把可调用对象（callable object）作为参数传给子线程的构造函数，则把该可调用对象复制一份给子线程。如果需要传递可调用对象的左值引用给子线程，则采用std::ref( )來產生对象的引用、然後把引用值再傳進去给子线程。 *类thread的构造函数： **thread() noexcept;缺省构造函数，线程不可执行 **template <class Fn, class... Args> explicit thread (Fn&& fn, Args&&... args); 最常用的构造函数 **thread (const thread&) = delete; 禁止复制构造 **thread (thread&& x) noexcept; 允许移动构造 *类thread的运算符 **thread& operator= (thread&& rhs) noexcept; **thread& operator= (const thread&) = delete; *类thread的成员函数： **thread::hardware_concurrency()： 静态成员函数，返回当前计算机最大的硬件并发线程数目。基本上可以視為處理器的核心數目。 **thread::get_id()： 返回一个线程对象的id **thread::joinable()：检查thread对象是否标识一个活动（active）的可行性行线程。具体说，判断表达式<code>get_id() != std::thread::id()</code>。缺省构造的thread对象、已经完成join的thread对象、已经detach的thread对象都不是joinable。 **thread::join()：阻塞调用者（caller）所在的线程直至被join的std::thread对象标识的线程执行结束。 **thread::detach：执行线程与当前的std::thread对象分开，线程继续独立执行下去。线程执行结束时释放分配的资源。 **thread::swap：线程swap **thread::native_handle：返回native handle ==this_thread命名空间== 在this_thread命名空间中定义了4个函数 *this_thread::get_id() 返回当前线程的id *this_thread::yield() 暫時放棄一段 CPU 時間、讓給其他线程使用 *this_thread::sleep_until() 設定一個絕對時刻、讓執行线程在指定的時刻后再繼續執行 *this_thread::sleep_for() 停止一段指定的時长的执行 ==例子程序== <syntaxhighlight lang="cpp"> #include <iostream> #include <thread> using namespace std; void test_func() { // do something cout << "In thread." << endl; } int main( int argc, char** argv ) { // execute thread thread mThread( test_func ); // do somthing cout << "main thread." << endl; // wait the thread stop mThread.join(); return 0; } </syntaxhighlight> 线程对象析构时，如果joinable()为真，将导致执行terminate()。所以应该按照RAII管理进程对象： <syntaxhighlight lang="cpp"> #include <iostream> #include <thread> class ThreadRAII { std::thread & m_thread; public: ThreadRAII(std::thread & threadObj) : m_thread(threadObj) { } ~ThreadRAII() { // Check if thread is joinable then detach the thread if(m_thread.joinable()) { m_thread.detach(); } } }; void thread_function() { for(int i = 0; i < 10000; i++); std::cout<<"thread_function Executing"<<std::endl; } int main() { std::thread threadObj(thread_function); // If we comment this Line, then program will crash ThreadRAII wrapperObj(threadObj); return 0; } </syntaxhighlight> 另外一个例子，构造了线程池： <syntaxhighlight lang="cpp"> #include<vector> #include<functional> #include<memory> #include <atomic> #include<list> #include<mutex> #include<thread> #include<condition_variable> #include <iostream> using namespace std; template<typename T> class SyncQueue { public: SyncQueue(int maxSize) :m_maxSize(maxSize), m_needStop(false) { } void Put(const T&x) { Add(x); } void Put(T&&x) { Add(std::forward<T>(x)); } void Take(std::list<T>& list) { std::unique_lock<std::mutex> locker(m_mutex); m_notEmpty.wait(locker, [this] {return m_needStop || NotEmpty(); }); if (m_needStop) return; list = std::move(m_queue); m_notFull.notify_one(); } void Take(T& t) { std::unique_lock<std::mutex> locker(m_mutex); m_notEmpty.wait(locker, [this] {return m_needStop || NotEmpty(); }); if (m_needStop) return; t = m_queue.front(); m_queue.pop_front(); m_notFull.notify_one(); } void Stop() { { std::lock_guard<std::mutex> locker(m_mutex); m_needStop = true; } m_notFull.notify_all(); m_notEmpty.notify_all(); } bool Empty() { std::lock_guard<std::mutex> locker(m_mutex); return m_queue.empty(); } bool Full() { std::lock_guard<std::mutex> locker(m_mutex); return m_queue.size() == m_maxSize; } size_t Size() { std::lock_guard<std::mutex> locker(m_mutex); return m_queue.size(); } int Count() { return m_queue.size(); } private: bool NotFull() const { bool full = m_queue.size() >= m_maxSize; if (full) cout << "full, waiting，thread id: " << this_thread::get_id() << endl; return !full; } bool NotEmpty() const { bool empty = m_queue.empty(); if (empty) cout << "empty,waiting，thread id: " << this_thread::get_id() << endl; return !empty; } template<typename F> void Add(F&&x) { std::unique_lock< std::mutex> locker(m_mutex); m_notFull.wait(locker, [this] {return m_needStop || NotFull(); }); if (m_needStop) return; m_queue.push_back(std::forward<F>(x)); m_notEmpty.notify_one(); } private: std::list<T> m_queue; //缓冲区 std::mutex m_mutex; //互斥量和条件变量结合起来使用 std::condition_variable m_notEmpty;//不为空的条件变量 std::condition_variable m_notFull; //没有满的条件变量 int m_maxSize; //同步队列最大的size bool m_needStop; //停止的标志 }; const int MaxTaskCount = 100; class ThreadPool { public: using Task = std::function<void()>; ThreadPool(int numThreads = std::thread::hardware_concurrency()) : m_queue(MaxTaskCount) { Start(numThreads); } ~ThreadPool(void) { //如果没有停止时则主动停止线程池 Stop(); } void Stop() { std::call_once(m_flag, [this] {StopThreadGroup(); }); //保证多线程情况下只调用一次StopThreadGroup } void AddTask(Task&&task) { m_queue.Put(std::forward<Task>(task)); } void AddTask(const Task& task) { m_queue.Put(task); } private: void Start(int numThreads) { m_running = true; //创建线程组 for (int i = 0; i <numThreads; ++i) { m_threadgroup.push_back(std::make_shared<std::thread>(&ThreadPool::RunInThread, this)); } } void RunInThread() { while (m_running) { //取任务分别执行 std::list<Task> list; m_queue.Take(list); for (auto& task : list) { if (!m_running) return; task(); } } } void StopThreadGroup() { m_queue.Stop(); //让同步队列中的线程停止 m_running = false; //置为false，让内部线程跳出循环并退出 for (auto thread : m_threadgroup) //等待线程结束 { if (thread) thread->join(); } m_threadgroup.clear(); } std::list<std::shared_ptr<std::thread>> m_threadgroup; //处理任务的线程组 SyncQueue<Task> m_queue; //同步队列 atomic_bool m_running; //是否停止的标志 std::once_flag m_flag; }; void TestThdPool() { ThreadPool pool; bool runing = true; std::thread thd1([&pool, &runing] { while (runing) { cout << "produce " << this_thread::get_id() << endl; pool.AddTask([] { std::cout << "consume " << this_thread::get_id() << endl; }); } }); this_thread::sleep_for(std::chrono::seconds(10)); runing = false; pool.Stop(); thd1.join(); getchar(); } int main() { TestThdPool(); } </syntaxhighlight> ==参考文献== <references/> 1vk0n02d5kb7dxxtbgcjnmjscfoa10o 168532 168531 2022-08-25T05:35:11Z Paho.mqtt 60409 wikitext text/x-wiki '''thread''' 是[[:w:C++標準程式庫]]中的一個[[:w:头文件]]，定义了[[:w:C++11]]标准中的一些表示[[:w:线程]]的类 、用于互斥访问的类与方法等。 ==线程对象thread== 类thread表示一个线程。初始化时给出该线程的执行函数（或是可以调用的对象）。线程对象构造后即开始运行。默认情况下，C++11的如此创建的线程必须与父线程会合，即在父线程中调用thread::join()函数，或者与父线程分离，即调用thread::detach()函数。否则，如果子线程还在执行，父线程已经执行结束而撤销，则会抛出异常。 如果子线程的执行函数需要参数，可把实参列表写在thread对象构造函数的参数表中。 如果把可调用对象（callable object）作为参数传给子线程的构造函数，则把该可调用对象复制一份给子线程。如果需要传递可调用对象的左值引用给子线程，则采用std::ref( )來產生对象的引用、然後把引用值再傳進去给子线程。 *类thread的构造函数： **thread() noexcept;缺省构造函数，线程不可执行 **template <class Fn, class... Args> explicit thread (Fn&& fn, Args&&... args); 最常用的构造函数 **thread (const thread&) = delete; 禁止复制构造 **thread (thread&& x) noexcept; 允许移动构造 *类thread的运算符 **thread& operator= (thread&& rhs) noexcept; **thread& operator= (const thread&) = delete; *类thread的成员函数： **thread::hardware_concurrency()： 静态成员函数，返回当前计算机最大的硬件并发线程数目。基本上可以視為處理器的核心數目。 **thread::get_id()： 返回一个线程对象的id **thread::joinable()：检查thread对象是否标识一个活动（active）的可行性行线程。具体说，判断表达式<code>get_id() != std::thread::id()</code>。缺省构造的thread对象、已经完成join的thread对象、已经detach的thread对象都不是joinable。 **thread::join()：阻塞调用者（caller）所在的线程直至被join的std::thread对象标识的线程执行结束。 **thread::detach：执行线程与当前的std::thread对象分开，线程继续独立执行下去。线程执行结束时释放分配的资源。 **thread::swap：线程swap **thread::native_handle：返回native handle ==this_thread命名空间== 在this_thread命名空间中定义了4个函数 *this_thread::get_id() 返回当前线程的id *this_thread::yield() 暫時放棄一段 CPU 時間、讓給其他线程使用 *this_thread::sleep_until() 設定一個絕對時刻、讓執行线程在指定的時刻后再繼續執行 *this_thread::sleep_for() 停止一段指定的時长的执行 ==例子程序== <syntaxhighlight lang="cpp"> #include <iostream> #include <thread> using namespace std; void test_func() { // do something cout << "In thread." << endl; } int main( int argc, char** argv ) { // execute thread thread mThread( test_func ); // do somthing cout << "main thread." << endl; // wait the thread stop mThread.join(); return 0; } </syntaxhighlight> 线程对象析构时，如果joinable()为真，将导致执行terminate()。所以应该按照RAII管理进程对象： <syntaxhighlight lang="cpp"> #include <iostream> #include <thread> class ThreadRAII { std::thread & m_thread; public: ThreadRAII(std::thread & threadObj) : m_thread(threadObj) { } ~ThreadRAII() { // Check if thread is joinable then detach the thread if(m_thread.joinable()) { m_thread.detach(); } } }; void thread_function() { for(int i = 0; i < 10000; i++); std::cout<<"thread_function Executing"<<std::endl; } int main() { std::thread threadObj(thread_function); // If we comment this Line, then program will crash ThreadRAII wrapperObj(threadObj); return 0; } </syntaxhighlight> 构造线程对象时，函数的参数哪怕是引用型，实际上也是给其构造了一个副本。为了确实传引用，需要使用std::ref()： <syntaxhighlight lang="cpp"> #include <iostream> #include <thread> void threadCallback(int const & x) { int & y = const_cast<int &>(x); y++; std::cout<<"Inside Thread x = "<<x<<std::endl; } int main() { int x = 9; std::cout<<"In Main Thread : Before Thread Start x = "<<x<<std::endl; std::thread threadObj(threadCallback,std::ref(x)); threadObj.join(); std::cout<<"In Main Thread : After Thread Joins x = "<<x<<std::endl; return 0; } </syntaxhighlight> 另外一个例子，构造了线程池： <syntaxhighlight lang="cpp"> #include<vector> #include<functional> #include<memory> #include <atomic> #include<list> #include<mutex> #include<thread> #include<condition_variable> #include <iostream> using namespace std; template<typename T> class SyncQueue { public: SyncQueue(int maxSize) :m_maxSize(maxSize), m_needStop(false) { } void Put(const T&x) { Add(x); } void Put(T&&x) { Add(std::forward<T>(x)); } void Take(std::list<T>& list) { std::unique_lock<std::mutex> locker(m_mutex); m_notEmpty.wait(locker, [this] {return m_needStop || NotEmpty(); }); if (m_needStop) return; list = std::move(m_queue); m_notFull.notify_one(); } void Take(T& t) { std::unique_lock<std::mutex> locker(m_mutex); m_notEmpty.wait(locker, [this] {return m_needStop || NotEmpty(); }); if (m_needStop) return; t = m_queue.front(); m_queue.pop_front(); m_notFull.notify_one(); } void Stop() { { std::lock_guard<std::mutex> locker(m_mutex); m_needStop = true; } m_notFull.notify_all(); m_notEmpty.notify_all(); } bool Empty() { std::lock_guard<std::mutex> locker(m_mutex); return m_queue.empty(); } bool Full() { std::lock_guard<std::mutex> locker(m_mutex); return m_queue.size() == m_maxSize; } size_t Size() { std::lock_guard<std::mutex> locker(m_mutex); return m_queue.size(); } int Count() { return m_queue.size(); } private: bool NotFull() const { bool full = m_queue.size() >= m_maxSize; if (full) cout << "full, waiting，thread id: " << this_thread::get_id() << endl; return !full; } bool NotEmpty() const { bool empty = m_queue.empty(); if (empty) cout << "empty,waiting，thread id: " << this_thread::get_id() << endl; return !empty; } template<typename F> void Add(F&&x) { std::unique_lock< std::mutex> locker(m_mutex); m_notFull.wait(locker, [this] {return m_needStop || NotFull(); }); if (m_needStop) return; m_queue.push_back(std::forward<F>(x)); m_notEmpty.notify_one(); } private: std::list<T> m_queue; //缓冲区 std::mutex m_mutex; //互斥量和条件变量结合起来使用 std::condition_variable m_notEmpty;//不为空的条件变量 std::condition_variable m_notFull; //没有满的条件变量 int m_maxSize; //同步队列最大的size bool m_needStop; //停止的标志 }; const int MaxTaskCount = 100; class ThreadPool { public: using Task = std::function<void()>; ThreadPool(int numThreads = std::thread::hardware_concurrency()) : m_queue(MaxTaskCount) { Start(numThreads); } ~ThreadPool(void) { //如果没有停止时则主动停止线程池 Stop(); } void Stop() { std::call_once(m_flag, [this] {StopThreadGroup(); }); //保证多线程情况下只调用一次StopThreadGroup } void AddTask(Task&&task) { m_queue.Put(std::forward<Task>(task)); } void AddTask(const Task& task) { m_queue.Put(task); } private: void Start(int numThreads) { m_running = true; //创建线程组 for (int i = 0; i <numThreads; ++i) { m_threadgroup.push_back(std::make_shared<std::thread>(&ThreadPool::RunInThread, this)); } } void RunInThread() { while (m_running) { //取任务分别执行 std::list<Task> list; m_queue.Take(list); for (auto& task : list) { if (!m_running) return; task(); } } } void StopThreadGroup() { m_queue.Stop(); //让同步队列中的线程停止 m_running = false; //置为false，让内部线程跳出循环并退出 for (auto thread : m_threadgroup) //等待线程结束 { if (thread) thread->join(); } m_threadgroup.clear(); } std::list<std::shared_ptr<std::thread>> m_threadgroup; //处理任务的线程组 SyncQueue<Task> m_queue; //同步队列 atomic_bool m_running; //是否停止的标志 std::once_flag m_flag; }; void TestThdPool() { ThreadPool pool; bool runing = true; std::thread thd1([&pool, &runing] { while (runing) { cout << "produce " << this_thread::get_id() << endl; pool.AddTask([] { std::cout << "consume " << this_thread::get_id() << endl; }); } }); this_thread::sleep_for(std::chrono::seconds(10)); runing = false; pool.Stop(); thd1.join(); getchar(); } int main() { TestThdPool(); } </syntaxhighlight> ==参考文献== <references/> 7h60md025qplawi159bqr7n9gkw6mn7 0 29110 168534 168134 2022-08-25T06:43:19Z 123.192.180.30 wikitext text/x-wiki =生理功能= HDAC（histon deacetylase） 會移除組蛋白上 acetyl-lysine 的 acetyl group，使 lysine 末端 amino group 帶正電，與 DNA 上帶負電的磷酸基團形成交互作用力而使染色體結構變得緊密，讓 RNA 轉錄酶難以靠近而降低基因轉錄，相反地，與 HDAC 持相反作用的 HAT (histone acetyltransferase）則會把 acetyl group 從 acetyl-CoA 轉移到 histone，消除組蛋白上 lysine 所帶的正電，與 DNA 磷酸基團之間的結合力減弱，染色體結構變鬆散，使 RNA 聚合酶容易靠近而增加該基因的轉錄 [[File:Histone acetylation and deacetylation.jpg|400px]] [[File:Mechanism_of_HDAC.svg]] =HDAC 分類= 截至目前為止，在人體細胞上共鑑定出 18 種 HDAC：HDAC1-11 與 SIRT1-7，數字代表發現的先後順序。依照它們與酵母菌 HDAC 的相似度，可以分成四大類：Class I-IV，其中 Class I, II 與 IV，因為去乙醯化催化作用與鋅離子相關，統稱 zinc-dependent enzyme 或是 classical HDACs；Class III 的去乙醯化催化作用則與 NAD⁺ 相關，又稱為 NAD⁺-dependent enzyme。 ==Class I HDACs== Class I HDAC 有 HDAC 1,2,3 與 8，它們與酵母菌 Rpd3 相似。Class I HDAC 主要分佈在細胞核內。 1996 年科學家分離與鑑定出第一個人類 HDAC，並在之後命名為 HDAC1，同年也找到第二個人類 HDAC，並在之後命名為 HDAC2。HDAC1 與 HDAC2 影響很多基因與 non-histone protein，像是 p53。HDAC1 和 HDAC2 將 p53 上的 acetyl group 移除掉，促使 p53 ubiquitination 然後被蛋白酶分解。HDAC1 和 HDAC2 與其他 HDAC 一樣，需要與其他蛋白質形成復合物才具有活性，諸如 NuRD（nucleosome remodeling histone deacetylase complex） HDAC3 與 HDAC8 有 34% 相似，HDAC3 也要與其他蛋白質形成復合物才具有活性，像是 SMRT（silencing mediator for retinoid acid and thyroid hormone receptors）以及 N-CoR（nuclear receptor co-repressor） HDAC8 可以分佈在細胞核與細胞質。相比 HDAC1-3，HDAC8 缺少 C 端 protein binding domain，這個結構差異或許能解釋為何 HDAC8 不像其他 class I HDAC，不需形成復合物就有活性。除此之外，磷酸化 HDAC8 會降低其活性，而磷酸化其他 class I HDAC（即 HDAC1-3）則會活性增加。另外，HDAC8 與 HDAC10 都能移除超過八個碳長鏈上的 acetyl group。 ==Class II HDACs== Class II HDACs 與酵母菌 Hda1 相似。Class II HDACs 能分佈在細胞核與細胞質中。Class II 可以細分成 IIa 和 IIb。IIa 有 HDAC4, 5, 7 和 9，IIb 有 HDAC6 和 HDAC10。 ===Class IIa HDACs=== HDAC4 能透過抑制轉錄因子 RunX2（run-related transcription factor 2）調節軟骨細胞增大與軟骨生成。HDAC4 和 HDAC5 能影響 MEF2 (myocyte enhancer factor2）而抑制 MyoD (myoblast determination protein 1），進而抑制肌肉生成。 在胸腺細胞中，HDAC7 能夠過促進 MEF2D 的轉錄與抑制 Nur77 (nuclear receptor 77）的表現來調節 T cell 的細胞凋亡。HDAC7 也與心血管發展有關，去除老鼠 HDAC7 基因會使血管擴張與破裂，讓老鼠在胚胎時期就亡。 HDAC9 大量表現於腦、骨骼肌和胚胎時期的心臟，但在心臟中表現量極低，表示 HDAC9 與心臟發展有關。除此之外，HDAC9 能夠過抑制 MEF2 的轉錄來調節肌肉細胞分化。 ===Class IIb HDACs=== Class IIb 與其他 HDACs 相比最特別之處是它們有兩個催化 site。 HDAC6 是人體中氨基酸序列最長的 HDAC，共有 1215 個氨基酸，且有兩個互相獨立的 deacetylase domain。第二個催化 domain（CD2）可以將細胞質的蛋白質去乙醯化，像是將 α-tubulin 上的 lysine40 去乙醯化來調節微管依賴細胞移動，或是將熱休克蛋白 90（heat shock protein 90, HSP90）去乙醯化來調節蛋白質恆定。CD1 的功能目前依然未知，但有發現其與 E3 ubiquitin ligase 有關。 HDAC10 與 HDAC6 有 55% 序列相同，其第二個催化位目前還沒鑑定出來。HDAC10 能透過去乙醯化 HSP90 調節蛋白酶分解 VEGFR。 ==Class III HDACs== Class III HDACs 與酵母菌 Sir2 相似。Class III HDACs 有 SIRT1-7。Class III HDACs 除了有 histone deacetylase 活性外，亦有 mono-ADP ribosyltransferase 活性。 ==Class IV HDACs== Class IV 只有 HDAC11。HDAC11 有很弱的 deacetylase 活性卻可以移除長鏈上的 acetyl group。 =催化機轉= ==Zinc-dependent HDACs== Zinc-dependent HDACs 的催化機轉一開始由 Finnin 觀察細菌 HDLP (HDAC-like protein）後提出，後來在 HDAC8 的結構中確定催化機轉。<i>N</i>-acetyl lysine 上 C=O 基團的氧原子會與鋅離子鍵結而增加 C=O 之碳原子的親電性（因為變得比較缺電子），另外 His143（HDAC8）會增加水分子的親核性，使得水分子親核性攻擊 C=O 基團之碳原子，形成 tetrahedral 中間體結構。oxyanion 中間體可以被鋅離子與氧之間的交互作用力，以及與 Tyr306 形成的氫鍵穩定。最後中間體的碳氮鍵斷掉，amide 氮接受 His143 的質子，產生醋酸鹽與 lysine [[File:Mechanism of Zn2+-HDAC.svg|center|800px]] ==NAD-dependent HDAC== =HDAC 結構= =與癌症的關係= HDAC 在大部分的癌症是表現量過度增加，過度表現的 HDAC 會抑制很多基因的轉錄，尤其是 tumor suppressor gene，讓細胞失去抑制癌症生成的功能，以及影響很多 non-histone protein 的活性，這些被影響的基因和蛋白質與癌症的 cell cycle, apoptosis, DNA damage repair, metastasis, angiogenesis 與 autophagy 相關 sov0a9z2lz9fhv9agq5t1l3l3afl8az 0 29121 168536 128854 2022-08-25T06:52:44Z 葉智海 37921 wikitext text/x-wiki *HDAC 抑制劑依其化學結構可大致分成五大類：hydroxyamic acids, benzamides, cyclic tetrapeptides, 和短鏈脂肪酸與其他。 *大部分藥物結構大致可以分成三個部分 **Hydrophobic cap：與 HDAC 催化位外緣鍵結，通常可以決定藥物對 HDAC 的選擇性 **Linker：連接 ZBG 和 Hydrophobic cap，讓 ZBG 可以通過狹長通道，進入催化位底部與 zinc ion 鍵結 **Zinc binding group (ZBG)：hydroxamate, benzamide 和 thiol，與 zinc ion 交互作用，發揮藥理作用 *截至目前，總共有四個 HDAC 抑制劑被美國 FDA 核准 =Hydroxyamic acids= ==General structure== [[Image:General hydroxamic acid.png|300px]] R' = H ==代表藥物== *[[/Trichostatin A/]] *[[/Vorinostat/]](SAHA) *[[/Pabobinostat/]](LBH589) =Short-chain fatty acids= *這類化合物藥效較低，但可以作為研究 HDAC 抑制劑的工具 *Butyric acid 和 Valproic acid 是第一個已知的 HDAC 抑制劑 *Tribityrin，是 Butyric acid 的前驅藥，已進入臨床試驗 *Valproic acid，是抗癲癇藥，亦是 HDAC1 和 HDAC2 抑制劑，現在進行子宮頸癌和卵巢癌、與 all-trans retinoic acid 併用治療老人之急性骨髓性白血病的臨床試驗 <gallery> File:Butyric acid acsv.svg|300px|Butyric acid File:Tributyrin.png|300px|Tributyrin File:Valproic_acid.svg|300px|Valproic acid </gallery> =Cyclic tetrapeptides= ==Romidepsin== *從<i>Chromobacterium</i>分離出的環酯肽 *2009 年 FDA 核准治療皮膚T細胞淋巴癌，但 2012 被歐洲藥品管理局拒絕 [[File: Romidepsin structure.png|300px]] *是一個前驅藥，進入細胞後被 glutathione 還原成具有生物活性的 RedFK，與 HDAC pocket 唯一的 cysteine 形成共價雙硫鍵 [[File:Romidepsin_bioactivation.svg]] ==Trapoxins== *Trapoxins A 和 B 是從真菌 <i>Helicoma ambient</i> 分離出的疏水性四胜肽 *Trapoxins 有兩個 phenylalanines 和一個夾帶 epoxide 基團的氨基酸 *Trapoxins A 含有 pipecolinic acid 基團；Trapoxins B 含有 proline 基團 *用 epoxide 與 HDAC 形成共價鍵結，不可逆抑制 HDAC *因為毒性而無法做臨床使用 ==Apicidin== *SAR 研究發現 α-epoxyketone 基團非活性必須，所以將其移除 *亦是真菌的代謝物，具有抗原蟲活性，也可抑制 HDACs *正在做臨床試驗 [[File:Apicidin.svg]] ==CHAP-31== *Trapoxin B 的 epoxy 基團以 hydroxamate 取代 *正在做臨床試驗 =Benzamides= *Entinostat, Tacedinaline, Mocetinostat *正在做臨床試驗 *N-phenylbenzamide 鄰位上的 amino 基團是活性必須 <gallery> File:Entinostat.svg|450px|Entinostat File:mocetinostat.png|450px| Mocetinostat </gallery> =Thiols= ==Psammplin A== *海洋生物的代謝產物 *除了會抑制 HDAC 外，也會抑制 topoisomerase II 和 aminopeptidase N [[File:Bioactivation_of_Psammaplin_A.svg]] *做為 HDAC 抑制劑構效關係研究 ==其他== *以 Psammplin A 的 SAR，用電腦模擬出 N-2-(thioethyl)picolonamide *因為 thiol 代謝穩定度低，所以將其轉成 thioester 63mx03irryvrxw0rp5sc2cacrqzuj6g 168537 168536 2022-08-25T06:53:05Z 葉智海 37921 /* 代表藥物 */ wikitext text/x-wiki *HDAC 抑制劑依其化學結構可大致分成五大類：hydroxyamic acids, benzamides, cyclic tetrapeptides, 和短鏈脂肪酸與其他。 *大部分藥物結構大致可以分成三個部分 **Hydrophobic cap：與 HDAC 催化位外緣鍵結，通常可以決定藥物對 HDAC 的選擇性 **Linker：連接 ZBG 和 Hydrophobic cap，讓 ZBG 可以通過狹長通道，進入催化位底部與 zinc ion 鍵結 **Zinc binding group (ZBG)：hydroxamate, benzamide 和 thiol，與 zinc ion 交互作用，發揮藥理作用 *截至目前，總共有四個 HDAC 抑制劑被美國 FDA 核准 =Hydroxyamic acids= ==General structure== [[Image:General hydroxamic acid.png|300px]] R' = H ==代表藥物== *[[/Trichostatin A/]] *[[/Vorinostat/]] (SAHA) *[[/Pabobinostat/]] (LBH589) =Short-chain fatty acids= *這類化合物藥效較低，但可以作為研究 HDAC 抑制劑的工具 *Butyric acid 和 Valproic acid 是第一個已知的 HDAC 抑制劑 *Tribityrin，是 Butyric acid 的前驅藥，已進入臨床試驗 *Valproic acid，是抗癲癇藥，亦是 HDAC1 和 HDAC2 抑制劑，現在進行子宮頸癌和卵巢癌、與 all-trans retinoic acid 併用治療老人之急性骨髓性白血病的臨床試驗 <gallery> File:Butyric acid acsv.svg|300px|Butyric acid File:Tributyrin.png|300px|Tributyrin File:Valproic_acid.svg|300px|Valproic acid </gallery> =Cyclic tetrapeptides= ==Romidepsin== *從<i>Chromobacterium</i>分離出的環酯肽 *2009 年 FDA 核准治療皮膚T細胞淋巴癌，但 2012 被歐洲藥品管理局拒絕 [[File: Romidepsin structure.png|300px]] *是一個前驅藥，進入細胞後被 glutathione 還原成具有生物活性的 RedFK，與 HDAC pocket 唯一的 cysteine 形成共價雙硫鍵 [[File:Romidepsin_bioactivation.svg]] ==Trapoxins== *Trapoxins A 和 B 是從真菌 <i>Helicoma ambient</i> 分離出的疏水性四胜肽 *Trapoxins 有兩個 phenylalanines 和一個夾帶 epoxide 基團的氨基酸 *Trapoxins A 含有 pipecolinic acid 基團；Trapoxins B 含有 proline 基團 *用 epoxide 與 HDAC 形成共價鍵結，不可逆抑制 HDAC *因為毒性而無法做臨床使用 ==Apicidin== *SAR 研究發現 α-epoxyketone 基團非活性必須，所以將其移除 *亦是真菌的代謝物，具有抗原蟲活性，也可抑制 HDACs *正在做臨床試驗 [[File:Apicidin.svg]] ==CHAP-31== *Trapoxin B 的 epoxy 基團以 hydroxamate 取代 *正在做臨床試驗 =Benzamides= *Entinostat, Tacedinaline, Mocetinostat *正在做臨床試驗 *N-phenylbenzamide 鄰位上的 amino 基團是活性必須 <gallery> File:Entinostat.svg|450px|Entinostat File:mocetinostat.png|450px| Mocetinostat </gallery> =Thiols= ==Psammplin A== *海洋生物的代謝產物 *除了會抑制 HDAC 外，也會抑制 topoisomerase II 和 aminopeptidase N [[File:Bioactivation_of_Psammaplin_A.svg]] *做為 HDAC 抑制劑構效關係研究 ==其他== *以 Psammplin A 的 SAR，用電腦模擬出 N-2-(thioethyl)picolonamide *因為 thiol 代謝穩定度低，所以將其轉成 thioester mgqcgnykv0xi8fzpvey8irdwi5o2osa 168538 168537 2022-08-25T06:53:26Z 葉智海 37921 /* General structure */ wikitext text/x-wiki *HDAC 抑制劑依其化學結構可大致分成五大類：hydroxyamic acids, benzamides, cyclic tetrapeptides, 和短鏈脂肪酸與其他。 *大部分藥物結構大致可以分成三個部分 **Hydrophobic cap：與 HDAC 催化位外緣鍵結，通常可以決定藥物對 HDAC 的選擇性 **Linker：連接 ZBG 和 Hydrophobic cap，讓 ZBG 可以通過狹長通道，進入催化位底部與 zinc ion 鍵結 **Zinc binding group (ZBG)：hydroxamate, benzamide 和 thiol，與 zinc ion 交互作用，發揮藥理作用 *截至目前，總共有四個 HDAC 抑制劑被美國 FDA 核准 =Hydroxyamic acids= ==General structure== R' = H [[Image:General hydroxamic acid.png|200px]] ==代表藥物== *[[/Trichostatin A/]] *[[/Vorinostat/]] (SAHA) *[[/Pabobinostat/]] (LBH589) =Short-chain fatty acids= *這類化合物藥效較低，但可以作為研究 HDAC 抑制劑的工具 *Butyric acid 和 Valproic acid 是第一個已知的 HDAC 抑制劑 *Tribityrin，是 Butyric acid 的前驅藥，已進入臨床試驗 *Valproic acid，是抗癲癇藥，亦是 HDAC1 和 HDAC2 抑制劑，現在進行子宮頸癌和卵巢癌、與 all-trans retinoic acid 併用治療老人之急性骨髓性白血病的臨床試驗 <gallery> File:Butyric acid acsv.svg|300px|Butyric acid File:Tributyrin.png|300px|Tributyrin File:Valproic_acid.svg|300px|Valproic acid </gallery> =Cyclic tetrapeptides= ==Romidepsin== *從<i>Chromobacterium</i>分離出的環酯肽 *2009 年 FDA 核准治療皮膚T細胞淋巴癌，但 2012 被歐洲藥品管理局拒絕 [[File: Romidepsin structure.png|300px]] *是一個前驅藥，進入細胞後被 glutathione 還原成具有生物活性的 RedFK，與 HDAC pocket 唯一的 cysteine 形成共價雙硫鍵 [[File:Romidepsin_bioactivation.svg]] ==Trapoxins== *Trapoxins A 和 B 是從真菌 <i>Helicoma ambient</i> 分離出的疏水性四胜肽 *Trapoxins 有兩個 phenylalanines 和一個夾帶 epoxide 基團的氨基酸 *Trapoxins A 含有 pipecolinic acid 基團；Trapoxins B 含有 proline 基團 *用 epoxide 與 HDAC 形成共價鍵結，不可逆抑制 HDAC *因為毒性而無法做臨床使用 ==Apicidin== *SAR 研究發現 α-epoxyketone 基團非活性必須，所以將其移除 *亦是真菌的代謝物，具有抗原蟲活性，也可抑制 HDACs *正在做臨床試驗 [[File:Apicidin.svg]] ==CHAP-31== *Trapoxin B 的 epoxy 基團以 hydroxamate 取代 *正在做臨床試驗 =Benzamides= *Entinostat, Tacedinaline, Mocetinostat *正在做臨床試驗 *N-phenylbenzamide 鄰位上的 amino 基團是活性必須 <gallery> File:Entinostat.svg|450px|Entinostat File:mocetinostat.png|450px| Mocetinostat </gallery> =Thiols= ==Psammplin A== *海洋生物的代謝產物 *除了會抑制 HDAC 外，也會抑制 topoisomerase II 和 aminopeptidase N [[File:Bioactivation_of_Psammaplin_A.svg]] *做為 HDAC 抑制劑構效關係研究 ==其他== *以 Psammplin A 的 SAR，用電腦模擬出 N-2-(thioethyl)picolonamide *因為 thiol 代謝穩定度低，所以將其轉成 thioester al96n2vsw31knwfrbtmm1xp4irteaxm 168541 168538 2022-08-25T07:03:04Z 葉智海 37921 /* 代表藥物 */ wikitext text/x-wiki *HDAC 抑制劑依其化學結構可大致分成五大類：hydroxyamic acids, benzamides, cyclic tetrapeptides, 和短鏈脂肪酸與其他。 *大部分藥物結構大致可以分成三個部分 **Hydrophobic cap：與 HDAC 催化位外緣鍵結，通常可以決定藥物對 HDAC 的選擇性 **Linker：連接 ZBG 和 Hydrophobic cap，讓 ZBG 可以通過狹長通道，進入催化位底部與 zinc ion 鍵結 **Zinc binding group (ZBG)：hydroxamate, benzamide 和 thiol，與 zinc ion 交互作用，發揮藥理作用 *截至目前，總共有四個 HDAC 抑制劑被美國 FDA 核准 =Hydroxyamic acids= ==General structure== R' = H [[Image:General hydroxamic acid.png|200px]] ==代表藥物== *[[/Trichostatin A/]] *[[/Vorinostat/]] (SAHA) *[[/Pabobinostat/]] (LBH589) *[[/MPT0E028/]] *[[/MPT0B291/]] *[[/MPT0G211/]] =Short-chain fatty acids= *這類化合物藥效較低，但可以作為研究 HDAC 抑制劑的工具 *Butyric acid 和 Valproic acid 是第一個已知的 HDAC 抑制劑 *Tribityrin，是 Butyric acid 的前驅藥，已進入臨床試驗 *Valproic acid，是抗癲癇藥，亦是 HDAC1 和 HDAC2 抑制劑，現在進行子宮頸癌和卵巢癌、與 all-trans retinoic acid 併用治療老人之急性骨髓性白血病的臨床試驗 <gallery> File:Butyric acid acsv.svg|300px|Butyric acid File:Tributyrin.png|300px|Tributyrin File:Valproic_acid.svg|300px|Valproic acid </gallery> =Cyclic tetrapeptides= ==Romidepsin== *從<i>Chromobacterium</i>分離出的環酯肽 *2009 年 FDA 核准治療皮膚T細胞淋巴癌，但 2012 被歐洲藥品管理局拒絕 [[File: Romidepsin structure.png|300px]] *是一個前驅藥，進入細胞後被 glutathione 還原成具有生物活性的 RedFK，與 HDAC pocket 唯一的 cysteine 形成共價雙硫鍵 [[File:Romidepsin_bioactivation.svg]] ==Trapoxins== *Trapoxins A 和 B 是從真菌 <i>Helicoma ambient</i> 分離出的疏水性四胜肽 *Trapoxins 有兩個 phenylalanines 和一個夾帶 epoxide 基團的氨基酸 *Trapoxins A 含有 pipecolinic acid 基團；Trapoxins B 含有 proline 基團 *用 epoxide 與 HDAC 形成共價鍵結，不可逆抑制 HDAC *因為毒性而無法做臨床使用 ==Apicidin== *SAR 研究發現 α-epoxyketone 基團非活性必須，所以將其移除 *亦是真菌的代謝物，具有抗原蟲活性，也可抑制 HDACs *正在做臨床試驗 [[File:Apicidin.svg]] ==CHAP-31== *Trapoxin B 的 epoxy 基團以 hydroxamate 取代 *正在做臨床試驗 =Benzamides= *Entinostat, Tacedinaline, Mocetinostat *正在做臨床試驗 *N-phenylbenzamide 鄰位上的 amino 基團是活性必須 <gallery> File:Entinostat.svg|450px|Entinostat File:mocetinostat.png|450px| Mocetinostat </gallery> =Thiols= ==Psammplin A== *海洋生物的代謝產物 *除了會抑制 HDAC 外，也會抑制 topoisomerase II 和 aminopeptidase N [[File:Bioactivation_of_Psammaplin_A.svg]] *做為 HDAC 抑制劑構效關係研究 ==其他== *以 Psammplin A 的 SAR，用電腦模擬出 N-2-(thioethyl)picolonamide *因為 thiol 代謝穩定度低，所以將其轉成 thioester 2s9pne5bu9iulvf0wt3i7nm0chkrqtz 168548 168541 2022-08-25T09:07:37Z 葉智海 37921 /* 代表藥物 */ wikitext text/x-wiki *HDAC 抑制劑依其化學結構可大致分成五大類：hydroxyamic acids, benzamides, cyclic tetrapeptides, 和短鏈脂肪酸與其他。 *大部分藥物結構大致可以分成三個部分 **Hydrophobic cap：與 HDAC 催化位外緣鍵結，通常可以決定藥物對 HDAC 的選擇性 **Linker：連接 ZBG 和 Hydrophobic cap，讓 ZBG 可以通過狹長通道，進入催化位底部與 zinc ion 鍵結 **Zinc binding group (ZBG)：hydroxamate, benzamide 和 thiol，與 zinc ion 交互作用，發揮藥理作用 *截至目前，總共有四個 HDAC 抑制劑被美國 FDA 核准 =Hydroxyamic acids= ==General structure== R' = H [[Image:General hydroxamic acid.png|200px]] ==代表藥物== *[[/Trichostatin A/]] *[[/Vorinostat/]] (SAHA) *[[/Belinostat/]](PXD101) *[[/Pabobinostat/]] (LBH589) *[[/MPT0E028/]] *[[/MPT0B291/]] *[[/MPT0G211/]] =Short-chain fatty acids= *這類化合物藥效較低，但可以作為研究 HDAC 抑制劑的工具 *Butyric acid 和 Valproic acid 是第一個已知的 HDAC 抑制劑 *Tribityrin，是 Butyric acid 的前驅藥，已進入臨床試驗 *Valproic acid，是抗癲癇藥，亦是 HDAC1 和 HDAC2 抑制劑，現在進行子宮頸癌和卵巢癌、與 all-trans retinoic acid 併用治療老人之急性骨髓性白血病的臨床試驗 <gallery> File:Butyric acid acsv.svg|300px|Butyric acid File:Tributyrin.png|300px|Tributyrin File:Valproic_acid.svg|300px|Valproic acid </gallery> =Cyclic tetrapeptides= ==Romidepsin== *從<i>Chromobacterium</i>分離出的環酯肽 *2009 年 FDA 核准治療皮膚T細胞淋巴癌，但 2012 被歐洲藥品管理局拒絕 [[File: Romidepsin structure.png|300px]] *是一個前驅藥，進入細胞後被 glutathione 還原成具有生物活性的 RedFK，與 HDAC pocket 唯一的 cysteine 形成共價雙硫鍵 [[File:Romidepsin_bioactivation.svg]] ==Trapoxins== *Trapoxins A 和 B 是從真菌 <i>Helicoma ambient</i> 分離出的疏水性四胜肽 *Trapoxins 有兩個 phenylalanines 和一個夾帶 epoxide 基團的氨基酸 *Trapoxins A 含有 pipecolinic acid 基團；Trapoxins B 含有 proline 基團 *用 epoxide 與 HDAC 形成共價鍵結，不可逆抑制 HDAC *因為毒性而無法做臨床使用 ==Apicidin== *SAR 研究發現 α-epoxyketone 基團非活性必須，所以將其移除 *亦是真菌的代謝物，具有抗原蟲活性，也可抑制 HDACs *正在做臨床試驗 [[File:Apicidin.svg]] ==CHAP-31== *Trapoxin B 的 epoxy 基團以 hydroxamate 取代 *正在做臨床試驗 =Benzamides= *Entinostat, Tacedinaline, Mocetinostat *正在做臨床試驗 *N-phenylbenzamide 鄰位上的 amino 基團是活性必須 <gallery> File:Entinostat.svg|450px|Entinostat File:mocetinostat.png|450px| Mocetinostat </gallery> =Thiols= ==Psammplin A== *海洋生物的代謝產物 *除了會抑制 HDAC 外，也會抑制 topoisomerase II 和 aminopeptidase N [[File:Bioactivation_of_Psammaplin_A.svg]] *做為 HDAC 抑制劑構效關係研究 ==其他== *以 Psammplin A 的 SAR，用電腦模擬出 N-2-(thioethyl)picolonamide *因為 thiol 代謝穩定度低，所以將其轉成 thioester ont1ycvq93qpft5b9zfmirviusolovj 168549 168548 2022-08-25T09:07:54Z 葉智海 37921 /* 代表藥物 */ wikitext text/x-wiki *HDAC 抑制劑依其化學結構可大致分成五大類：hydroxyamic acids, benzamides, cyclic tetrapeptides, 和短鏈脂肪酸與其他。 *大部分藥物結構大致可以分成三個部分 **Hydrophobic cap：與 HDAC 催化位外緣鍵結，通常可以決定藥物對 HDAC 的選擇性 **Linker：連接 ZBG 和 Hydrophobic cap，讓 ZBG 可以通過狹長通道，進入催化位底部與 zinc ion 鍵結 **Zinc binding group (ZBG)：hydroxamate, benzamide 和 thiol，與 zinc ion 交互作用，發揮藥理作用 *截至目前，總共有四個 HDAC 抑制劑被美國 FDA 核准 =Hydroxyamic acids= ==General structure== R' = H [[Image:General hydroxamic acid.png|200px]] ==代表藥物== *[[/Trichostatin A/]] *[[/Vorinostat/]] (SAHA) *[[/Belinostat/]] (PXD101) *[[/Pabobinostat/]] (LBH589) *[[/MPT0E028/]] *[[/MPT0B291/]] *[[/MPT0G211/]] =Short-chain fatty acids= *這類化合物藥效較低，但可以作為研究 HDAC 抑制劑的工具 *Butyric acid 和 Valproic acid 是第一個已知的 HDAC 抑制劑 *Tribityrin，是 Butyric acid 的前驅藥，已進入臨床試驗 *Valproic acid，是抗癲癇藥，亦是 HDAC1 和 HDAC2 抑制劑，現在進行子宮頸癌和卵巢癌、與 all-trans retinoic acid 併用治療老人之急性骨髓性白血病的臨床試驗 <gallery> File:Butyric acid acsv.svg|300px|Butyric acid File:Tributyrin.png|300px|Tributyrin File:Valproic_acid.svg|300px|Valproic acid </gallery> =Cyclic tetrapeptides= ==Romidepsin== *從<i>Chromobacterium</i>分離出的環酯肽 *2009 年 FDA 核准治療皮膚T細胞淋巴癌，但 2012 被歐洲藥品管理局拒絕 [[File: Romidepsin structure.png|300px]] *是一個前驅藥，進入細胞後被 glutathione 還原成具有生物活性的 RedFK，與 HDAC pocket 唯一的 cysteine 形成共價雙硫鍵 [[File:Romidepsin_bioactivation.svg]] ==Trapoxins== *Trapoxins A 和 B 是從真菌 <i>Helicoma ambient</i> 分離出的疏水性四胜肽 *Trapoxins 有兩個 phenylalanines 和一個夾帶 epoxide 基團的氨基酸 *Trapoxins A 含有 pipecolinic acid 基團；Trapoxins B 含有 proline 基團 *用 epoxide 與 HDAC 形成共價鍵結，不可逆抑制 HDAC *因為毒性而無法做臨床使用 ==Apicidin== *SAR 研究發現 α-epoxyketone 基團非活性必須，所以將其移除 *亦是真菌的代謝物，具有抗原蟲活性，也可抑制 HDACs *正在做臨床試驗 [[File:Apicidin.svg]] ==CHAP-31== *Trapoxin B 的 epoxy 基團以 hydroxamate 取代 *正在做臨床試驗 =Benzamides= *Entinostat, Tacedinaline, Mocetinostat *正在做臨床試驗 *N-phenylbenzamide 鄰位上的 amino 基團是活性必須 <gallery> File:Entinostat.svg|450px|Entinostat File:mocetinostat.png|450px| Mocetinostat </gallery> =Thiols= ==Psammplin A== *海洋生物的代謝產物 *除了會抑制 HDAC 外，也會抑制 topoisomerase II 和 aminopeptidase N [[File:Bioactivation_of_Psammaplin_A.svg]] *做為 HDAC 抑制劑構效關係研究 ==其他== *以 Psammplin A 的 SAR，用電腦模擬出 N-2-(thioethyl)picolonamide *因為 thiol 代謝穩定度低，所以將其轉成 thioester p1xnvdlvr30l5jvj0bfaazf4tqyf4bk 4 32222 168529 168507 2022-08-24T12:19:35Z Alexis Jazz 55150 Updating gadget usage statistics from [[Special:GadgetUsage]] ([[phab:T121049]]) wikitext text/x-wiki {{#ifexist:Project:GUS2Wiki/top|{{/top}}|This page provides a historical record of [[Special:GadgetUsage]] through its page history. To get the data in CSV format, see wikitext. To customize this message or add categories, create [[/top]].}} 以下是缓存的数据，最后更新于2022-08-23T20:56:21Z。缓存中最多有{{PLURAL:5000|5000条结果}}。 {| class="sortable wikitable" ! 小工具 !! data-sort-type="number" | 用户人数 !! data-sort-type="number" | 活跃用户 |- |AdvancedSiteNotices || data-sort-value="Infinity" | 默认 || data-sort-value="Infinity" | 默认 |- |Blackskin || 15 || 0 |- |Cat-a-lot || 32 || 3 |- |CleanDeleteReasons || data-sort-value="Infinity" | 默认 || data-sort-value="Infinity" | 默认 |- |Edittools-VFD || 54 || 3 |- |Edittools-ZHC || 72 || 3 |- |Edittools-admin || 31 || 1 |- |Edittools-cite || 78 || 3 |- |Edittools-default || 60 || 2 |- |Edittools-plus || 123 || 3 |- |Edittools-user || 41 || 0 |- |HotCat || 105 || 3 |- |JSL || 88 || 3 |- |Navigation popups || 89 || 3 |- |PreviewWithVariant || 23 || 2 |- |UTCLiveClock || 91 || 2 |- |blinktalk || 34 || 0 |- |contribsrange || 52 || 2 |- |easy-archive || 10 || 1 |- |edit0 || 87 || 2 |- |hantsect || 51 || 0 |- |internalLinkHelper-altcolor || data-sort-value="Infinity" | 默认 || data-sort-value="Infinity" | 默认 |- |internalLinkHelper-cravix || 2 || 0 |- |internalLinkHelper-external || 1 || 0 |- |internalLinkHelper-ilbluehl || 3 || 0 |- |internalLinkHelper-redonly || 1 || 0 |- |internalLinkHelper-redplain || 2 || 0 |- |internalLinkHelper-redtipsy || 3 || 1 |- |internalLinkHelper-suffix || 3 || 0 |- |moveEditsection || 31 || 1 |- |noteTA || data-sort-value="Infinity" | 默认 || data-sort-value="Infinity" | 默认 |- |popupUserLanguage || 38 || 0 |- |removeAccessKeys || 18 || 0 |- |specialchars || 76 || 2 |- |wikEd || 70 || 0 |- |wikEd intl hans || 77 || 0 |- |wikEd intl hant || 50 || 0 |- |wikimediaplayer || 75 || 2 |} * [[Special:GadgetUsage]] * [[m:Meta:GUS2Wiki/Script|GUS2Wiki]] <!-- data in CSV format: AdvancedSiteNotices,default,default Blackskin,15,0 Cat-a-lot,32,3 CleanDeleteReasons,default,default Edittools-VFD,54,3 Edittools-ZHC,72,3 Edittools-admin,31,1 Edittools-cite,78,3 Edittools-default,60,2 Edittools-plus,123,3 Edittools-user,41,0 HotCat,105,3 JSL,88,3 Navigation popups,89,3 PreviewWithVariant,23,2 UTCLiveClock,91,2 blinktalk,34,0 contribsrange,52,2 easy-archive,10,1 edit0,87,2 hantsect,51,0 internalLinkHelper-altcolor,default,default internalLinkHelper-cravix,2,0 internalLinkHelper-external,1,0 internalLinkHelper-ilbluehl,3,0 internalLinkHelper-redonly,1,0 internalLinkHelper-redplain,2,0 internalLinkHelper-redtipsy,3,1 internalLinkHelper-suffix,3,0 moveEditsection,31,1 noteTA,default,default popupUserLanguage,38,0 removeAccessKeys,18,0 specialchars,76,2 wikEd,70,0 wikEd intl hans,77,0 wikEd intl hant,50,0 wikimediaplayer,75,2 --> ds9ksh29s00nh8o03q4ffkog8r07k4m 0 32337 168539 2022-08-25T06:55:13Z 葉智海 37921 创建页面，内容为“*亦叫 Suberoylanilide hydroxamic acid（SAHA），商品名 Zolinza *是此類第一個有進入人體試驗的化合物，也是第一個有上市的 HDAC 抑制劑 *結構中的 aniline 是 hydrophobic cap，hydroxamic acid 是 ZBG，中間六個碳即為 linker *2006 年 FDA 准許其用於經兩種全身性治療後仍出現進行性、持續性或復發性疾病表現之皮膚T細胞淋巴癌（Cutaneous T-cell lymphoma, CTCL），以及治療多發性…” wikitext text/x-wiki *亦叫 Suberoylanilide hydroxamic acid（SAHA），商品名 Zolinza *是此類第一個有進入人體試驗的化合物，也是第一個有上市的 HDAC 抑制劑 *結構中的 aniline 是 hydrophobic cap，hydroxamic acid 是 ZBG，中間六個碳即為 linker *2006 年 FDA 准許其用於經兩種全身性治療後仍出現進行性、持續性或復發性疾病表現之皮膚T細胞淋巴癌（Cutaneous T-cell lymphoma, CTCL），以及治療多發性骨髓瘤 *一開始只是科學家想知道為何 Dimethyl sulfoxide （DMSO）會導致老鼠紅血球母細胞生長停止和最後分化，在分子兩端接上 amide 基團，如果受體上有兩個以上可與 amide 互有吸引力的位置，便可與該化合物交互作用，而後合成出 Hexamethylene bisacetamide （HMBA）。 HMBA 的 amide 類似於 DMSO 的 sulfoxide，科學家認為其透過氫鍵或是和金屬離子螯合，與受體交互作用 *後來發現 hydroxamic acid 和受體鍵結能力比 amide 強，所以一系列 bishydroxamic acids 類化合物被合成，包括 siberia nishydroxamic acid（SBHA），鍵結能力比 HMBA 強 *藥物化學家想，如果 hydroxamic acid 是與金屬離子鍵結，那不可能需要兩個相同的基團，因此決定將其中一個 hydroxamic acid 基團改成疏水性基團，也就是 SAHA，造成細胞週期停止和細胞死亡的效價比 SBHA 強六倍。 [[File:Stage_in_the_design_of_vorinostat.svg]] *X 光晶體顯示（PDB 4LXZ）hydroxamic acid 基團與鋅離子螯合，phenyl 基團則躺在酵素的疏水表面 [[File:Interaction_of_vorinostat_with_HDAC2_active_site.svg]] fpz7zbmi4awyg39u10lyrsd7liqviwm 168543 168539 2022-08-25T08:38:42Z 葉智海 37921 wikitext text/x-wiki *亦叫 Suberoylanilide hydroxamic acid（SAHA），商品名 Zolinza *是 hydroxamic acid 類第一個進入人體試驗的化合物，也是第一個上市的 HDAC 抑制劑 *結構中的 aniline 是 hydrophobic cap，hydroxamic acid 是 ZBG，中間六個碳即為 linker *2006 年 FDA 准許其用於經兩種全身性治療後仍出現進行性、持續性或復發性疾病表現之皮膚T細胞淋巴癌（Cutaneous T-cell lymphoma, CTCL），以及治療多發性骨髓瘤 =藥物結構= [[File:Vorinostat.svg]] =發展歷史= 1996 年時 Charlotte Friend 發現當老鼠 erythroleukemia cells （MELC）使用 280 mmolar 的 dimethyl sulfoxide （DMSO）處理時，會有大約 60% 的細胞經過細胞分化變成正常的紅血球，Paul Marks（時任人類遺傳學與醫學教授） 與 Ronald Breslow（當時時任哥倫比亞大學化學教授）認為這會是治療癌症的新切入點，但當然不能直接拿 DMSO 當藥品給人體使用，因此他們合作針對 DMSO 結構做修飾，Breslow 實驗室負責藥物化學研究與合成，Marks 負責生物活性測試 在他們初步合成的結構中，其中 N-methylacetamide 的活性是 DMSO 的五倍，但仍不夠變成人體用的藥物。因此他們決定合成兩個 acetamide 並在中間以 linker 連接，使藥物左右兩邊都具有藥效基團（如果發揮藥理作用的關鍵結構是 acetamide），或許能提高效價，合成一系列不同長度的 linker，其中六碳鏈長鏈的 hexamethylene bisacetamide （HMBA）的活性最優異，效價比單純的 acetamide 高十倍；除此之外，他們也合成 suberoyl-bis-N-methylamide（將 HMBA 的 amide 調換，化合物 1），活性也比 acetamide 高十倍；亦試過將三個甚至四個 acetamide 接在一起，但活性就沒有所提升。經過進一步的生物活性測試，他們決定拿 HMBA 做人體試驗。雖然 HMBA 在癌症患者中表現出預期療效，但所需的劑量太高。 後來他們猜想或許這些 compounds 的作用目標是酵素，也許是 metalloenzyme（筆者也不知道他們怎麼猜的）。如果這是對的，那代表 DMSO 還有他們合成的 compound 上的 amides 會與金屬交互作用，因此他們決定找一個更好的 metal ion binders。他們合成 suberoyl-bis-N-methylamide 的類似物但以 OH 基團取代原本的甲基，suberoyl-bis-hydroxamic acid（SBHA）。SBHA 的活性比 HMBA 優異，說明真的有可能這些 compounds 會與金屬離子鍵結。如果真是如此，它們推想目標物會剛好有兩個 metal ion 且相隔差不多六個碳的距離的可能性不大，也就是說 compounds 只需要一個藥效基團就好，不必左右兩邊都需要，所以他們把其中一個 OH 換成親脂性的 phenyl group，讓 phenyl 能跟蛋白質上親脂的區域交互作用，而合成出 SAHA。也果真，SAHA 在 MELC 細胞中抑制 HDAC 的效價比 SBHA 高約六倍，調整中間 linker 長度發現六個碳的活性是最適合，將 phenyl group 換成其他親脂基團能增加藥物與 HDAC 的鍵結能力但也增加藥物的毒性。經過進一步的生物活性測試與老鼠試驗，他們決定將 SAHA 推上人體試驗 2001 年，Marks, Breslow 與 Richard Rifkind 共組 ATON Pharma Inc. 公司，獲得哥倫比亞大學與 Sloan Kettering 專利權移轉以及贊助他們做第一期人體試驗。一期人體試驗結果顯示 SAHA 是個具有潛力的抗癌藥，使得許多藥廠想要買下 ATON 與 SAHA 的專利和數據。2004 年，Merck 收購 ATON 並完後後續的人體試驗，讓 SAHA 在 2006 年被美國 FDA 核准，2009 年被加拿大監管機構核准，2011 年被日本核准。SAHA 的成功啟發後面 HDAC 抑制劑的開發與研究。 {|class="wikitable" |- |DMSO||Acetamide||HMBA||化合物 1||SBHA||SAHA |- |[[File:Dimethylsulfoxid.svg|150px]] |[[File:Acetamide skeletal.svg|150px]] |[[File:Hexamethylene bis- acetamide.png|200px]] |[[File:Suberoyl-bis-N-methylamide.png|200px]] |[[File:Suberyol-bis-hydroxamicacid.png|200px]] |[[File:Vorinostat.svg|200px]] |} X 光晶體顯示（PDB 4LXZ）hydroxamic acid 基團與鋅離子螯合，phenyl 基團則躺在酵素的疏水表面 [[File:Interaction_of_vorinostat_with_HDAC2_active_site.svg]] 06yovfgzy4hd0zowynt74b5ced53hor 168544 168543 2022-08-25T08:39:03Z 葉智海 37921 wikitext text/x-wiki *亦叫 Suberoylanilide hydroxamic acid（SAHA），商品名 Zolinza *是 hydroxamic acid 類第一個進入人體試驗的化合物，也是第一個上市的 HDAC 抑制劑 *結構中的 aniline 是 hydrophobic cap，hydroxamic acid 是 ZBG，中間六個碳即為 linker *2006 年 FDA 准許其用於經兩種全身性治療後仍出現進行性、持續性或復發性疾病表現之皮膚T細胞淋巴癌（Cutaneous T-cell lymphoma, CTCL），以及治療多發性骨髓瘤 =藥物結構= [[File:Vorinostat.svg]] =發展歷史= 1996 年時 Charlotte Friend 發現當老鼠 erythroleukemia cells （MELC）使用 280 mmolar 的 dimethyl sulfoxide （DMSO）處理時，會有大約 60% 的細胞經過細胞分化變成正常的紅血球，Paul Marks（時任人類遺傳學與醫學教授） 與 Ronald Breslow（當時時任哥倫比亞大學化學教授）認為這會是治療癌症的新切入點，但當然不能直接拿 DMSO 當藥品給人體使用，因此他們合作針對 DMSO 結構做修飾，Breslow 實驗室負責藥物化學研究與合成，Marks 負責生物活性測試 在他們初步合成的結構中，其中 N-methylacetamide 的活性是 DMSO 的五倍，但仍不夠變成人體用的藥物。因此他們決定合成兩個 acetamide 並在中間以 linker 連接，使藥物左右兩邊都具有藥效基團（如果發揮藥理作用的關鍵結構是 acetamide），或許能提高效價，合成一系列不同長度的 linker，其中六碳鏈長鏈的 hexamethylene bisacetamide （HMBA）的活性最優異，效價比單純的 acetamide 高十倍；除此之外，他們也合成 suberoyl-bis-N-methylamide（將 HMBA 的 amide 調換，化合物 1），活性也比 acetamide 高十倍；亦試過將三個甚至四個 acetamide 接在一起，但活性就沒有所提升。經過進一步的生物活性測試，他們決定拿 HMBA 做人體試驗。雖然 HMBA 在癌症患者中表現出預期療效，但所需的劑量太高。 後來他們猜想或許這些 compounds 的作用目標是酵素，也許是 metalloenzyme（筆者也不知道他們怎麼猜的）。如果這是對的，那代表 DMSO 還有他們合成的 compound 上的 amides 會與金屬交互作用，因此他們決定找一個更好的 metal ion binders。他們合成 suberoyl-bis-N-methylamide 的類似物但以 OH 基團取代原本的甲基，suberoyl-bis-hydroxamic acid（SBHA）。SBHA 的活性比 HMBA 優異，說明真的有可能這些 compounds 會與金屬離子鍵結。如果真是如此，它們推想目標物會剛好有兩個 metal ion 且相隔差不多六個碳的距離的可能性不大，也就是說 compounds 只需要一個藥效基團就好，不必左右兩邊都需要，所以他們把其中一個 OH 換成親脂性的 phenyl group，讓 phenyl 能跟蛋白質上親脂的區域交互作用，而合成出 SAHA。也果真，SAHA 在 MELC 細胞中抑制 HDAC 的效價比 SBHA 高約六倍，調整中間 linker 長度發現六個碳的活性是最適合，將 phenyl group 換成其他親脂基團能增加藥物與 HDAC 的鍵結能力但也增加藥物的毒性。經過進一步的生物活性測試與老鼠試驗，他們決定將 SAHA 推上人體試驗 2001 年，Marks, Breslow 與 Richard Rifkind 共組 ATON Pharma Inc. 公司，獲得哥倫比亞大學與 Sloan Kettering 專利權移轉以及贊助他們做第一期人體試驗。一期人體試驗結果顯示 SAHA 是個具有潛力的抗癌藥，使得許多藥廠想要買下 ATON 與 SAHA 的專利和數據。2004 年，Merck 收購 ATON 並完後後續的人體試驗，讓 SAHA 在 2006 年被美國 FDA 核准，2009 年被加拿大監管機構核准，2011 年被日本核准。SAHA 的成功啟發後面 HDAC 抑制劑的開發與研究。 {|class="wikitable" |- |DMSO||Acetamide||HMBA||化合物 1||SBHA||SAHA |- |[[File:Dimethylsulfoxid.svg|150px]] |[[File:Acetamide skeletal.svg|150px]] |[[File:Hexamethylene bis- acetamide.png|200px]] |[[File:Suberoyl-bis-N-methylamide.png|200px]] |[[File:Suberyol-bis-hydroxamicacid.png|200px]] |[[File:Vorinostat.svg|200px]] |} X 光晶體顯示（PDB 4LXZ）hydroxamic acid 基團與鋅離子螯合，phenyl 基團則躺在酵素的疏水表面 [[File:Interaction_of_vorinostat_with_HDAC2_active_site.svg]] lwrn6ptntd9461ojgdn5ue4w8tk1ktl 168545 168544 2022-08-25T09:04:42Z 葉智海 37921 wikitext text/x-wiki *亦叫 Suberoylanilide hydroxamic acid（SAHA），商品名 Zolinza *是 hydroxamic acid 類第一個進入人體試驗的化合物，也是第一個上市的 HDAC 抑制劑 *結構中的 aniline 是 hydrophobic cap，hydroxamic acid 是 ZBG，中間六個碳即為 linker *2006 年 FDA 准許其用於經兩種全身性治療後仍出現進行性、持續性或復發性疾病表現之皮膚T細胞淋巴癌（Cutaneous T-cell lymphoma, CTCL），以及治療多發性骨髓瘤 =藥物結構= [[File:Vorinostat.svg]] =發展歷史= 1996 年時 Charlotte Friend 發現當老鼠 erythroleukemia cells （MELC）使用 280 mmolar 的 dimethyl sulfoxide （DMSO）處理時，會有大約 60% 的細胞經過細胞分化變成正常的紅血球，Paul Marks（時任人類遺傳學與醫學教授） 與 Ronald Breslow（當時時任哥倫比亞大學化學教授）認為這會是治療癌症的新切入點，但當然不能直接拿 DMSO 當藥品給人體使用，因此他們合作針對 DMSO 結構做修飾，Breslow 實驗室負責藥物化學研究與合成，Marks 負責生物活性測試 在他們初步合成的結構中，其中 N-methylacetamide 的活性是 DMSO 的五倍，但仍不夠變成人體用的藥物。因此他們決定合成兩個 acetamide 並在中間以 linker 連接，使藥物左右兩邊都具有藥效基團（如果發揮藥理作用的關鍵結構是 acetamide），或許能提高效價，合成一系列不同長度的 linker，其中六碳鏈長鏈的 hexamethylene bisacetamide （HMBA）的活性最優異，效價比單純的 acetamide 高十倍；除此之外，他們也合成 suberoyl-bis-N-methylamide（將 HMBA 的 amide 調換，化合物 1），活性也比 acetamide 高十倍；亦試過將三個甚至四個 acetamide 接在一起，但活性就沒有所提升。經過進一步的生物活性測試，他們決定拿 HMBA 做人體試驗。雖然 HMBA 在癌症患者中表現出預期療效，但所需的劑量太高。 後來他們猜想或許這些 compounds 的作用目標是酵素，也許是 metalloenzyme（筆者也不知道他們怎麼猜的）。如果這是對的，那代表 DMSO 還有他們合成的 compound 上的 amides 會與金屬交互作用，因此他們決定找一個更好的 metal ion binders。他們合成 suberoyl-bis-N-methylamide 的類似物但以 OH 基團取代原本的甲基，suberoyl-bis-hydroxamic acid（SBHA）。SBHA 的活性比 HMBA 優異，說明真的有可能這些 compounds 會與金屬離子鍵結。如果真是如此，它們推想目標物會剛好有兩個 metal ion 且相隔差不多六個碳的距離的可能性不大，也就是說 compounds 只需要一個藥效基團就好，不必左右兩邊都需要，所以他們把其中一個 OH 換成親脂性的 phenyl group，讓 phenyl 能跟蛋白質上親脂的區域交互作用，而合成出 SAHA。也果真，SAHA 在 MELC 細胞中抑制 HDAC 的效價比 SBHA 高約六倍，調整中間 linker 長度發現六個碳的活性是最適合，將 phenyl group 換成其他親脂基團能增加藥物與 HDAC 的鍵結能力但也增加藥物的毒性。經過進一步的生物活性測試與老鼠試驗，他們決定將 SAHA 推上人體試驗 2001 年，Marks, Breslow 與 Richard Rifkind 共組 ATON Pharma Inc. 公司，獲得哥倫比亞大學與 Sloan Kettering 專利權移轉以及贊助他們做第一期人體試驗。一期人體試驗結果顯示 SAHA 是個具有潛力的抗癌藥，使得許多藥廠想要買下 ATON 與 SAHA 的專利和數據。2004 年，Merck 收購 ATON 並完後後續的人體試驗，讓 SAHA 在 2006 年被美國 FDA 核准，2009 年被加拿大監管機構核准，2011 年被日本核准。SAHA 的成功啟發後面 HDAC 抑制劑的開發與研究。 {|class="wikitable" |- |DMSO||Acetamide||HMBA||化合物 1||SBHA||SAHA |- |[[File:Dimethylsulfoxid.svg|150px]] |[[File:Acetamide skeletal.svg|150px]] |[[File:Hexamethylene bis- acetamide.png|200px]] |[[File:Suberoyl-bis-N-methylamide.png|200px]] |[[File:Suberyol-bis-hydroxamicacid.png|200px]] |[[File:Vorinostat.svg|200px]] |} X 光晶體顯示（PDB 4LXZ）hydroxamic acid 基團與鋅離子螯合，phenyl 基團則躺在酵素的疏水表面 [[File:Interaction_of_vorinostat_with_HDAC2_active_site.svg]] =藥物合成= 此為其中一種方式，仍有需多合成方法 [[File:Synthesis of SAHA.png|thumb|Synthesis of SAHA]] njnpwhx6u0d4v4c1kwtut9eeykj9qsv 168546 168545 2022-08-25T09:04:50Z 葉智海 37921 wikitext text/x-wiki *亦叫 Suberoylanilide hydroxamic acid（SAHA），商品名 Zolinza *是 hydroxamic acid 類第一個進入人體試驗的化合物，也是第一個上市的 HDAC 抑制劑 *結構中的 aniline 是 hydrophobic cap，hydroxamic acid 是 ZBG，中間六個碳即為 linker *2006 年 FDA 准許其用於經兩種全身性治療後仍出現進行性、持續性或復發性疾病表現之皮膚T細胞淋巴癌（Cutaneous T-cell lymphoma, CTCL），以及治療多發性骨髓瘤 =藥物結構= [[File:Vorinostat.svg]] =發展歷史= 1996 年時 Charlotte Friend 發現當老鼠 erythroleukemia cells （MELC）使用 280 mmolar 的 dimethyl sulfoxide （DMSO）處理時，會有大約 60% 的細胞經過細胞分化變成正常的紅血球，Paul Marks（時任人類遺傳學與醫學教授） 與 Ronald Breslow（當時時任哥倫比亞大學化學教授）認為這會是治療癌症的新切入點，但當然不能直接拿 DMSO 當藥品給人體使用，因此他們合作針對 DMSO 結構做修飾，Breslow 實驗室負責藥物化學研究與合成，Marks 負責生物活性測試 在他們初步合成的結構中，其中 N-methylacetamide 的活性是 DMSO 的五倍，但仍不夠變成人體用的藥物。因此他們決定合成兩個 acetamide 並在中間以 linker 連接，使藥物左右兩邊都具有藥效基團（如果發揮藥理作用的關鍵結構是 acetamide），或許能提高效價，合成一系列不同長度的 linker，其中六碳鏈長鏈的 hexamethylene bisacetamide （HMBA）的活性最優異，效價比單純的 acetamide 高十倍；除此之外，他們也合成 suberoyl-bis-N-methylamide（將 HMBA 的 amide 調換，化合物 1），活性也比 acetamide 高十倍；亦試過將三個甚至四個 acetamide 接在一起，但活性就沒有所提升。經過進一步的生物活性測試，他們決定拿 HMBA 做人體試驗。雖然 HMBA 在癌症患者中表現出預期療效，但所需的劑量太高。 後來他們猜想或許這些 compounds 的作用目標是酵素，也許是 metalloenzyme（筆者也不知道他們怎麼猜的）。如果這是對的，那代表 DMSO 還有他們合成的 compound 上的 amides 會與金屬交互作用，因此他們決定找一個更好的 metal ion binders。他們合成 suberoyl-bis-N-methylamide 的類似物但以 OH 基團取代原本的甲基，suberoyl-bis-hydroxamic acid（SBHA）。SBHA 的活性比 HMBA 優異，說明真的有可能這些 compounds 會與金屬離子鍵結。如果真是如此，它們推想目標物會剛好有兩個 metal ion 且相隔差不多六個碳的距離的可能性不大，也就是說 compounds 只需要一個藥效基團就好，不必左右兩邊都需要，所以他們把其中一個 OH 換成親脂性的 phenyl group，讓 phenyl 能跟蛋白質上親脂的區域交互作用，而合成出 SAHA。也果真，SAHA 在 MELC 細胞中抑制 HDAC 的效價比 SBHA 高約六倍，調整中間 linker 長度發現六個碳的活性是最適合，將 phenyl group 換成其他親脂基團能增加藥物與 HDAC 的鍵結能力但也增加藥物的毒性。經過進一步的生物活性測試與老鼠試驗，他們決定將 SAHA 推上人體試驗 2001 年，Marks, Breslow 與 Richard Rifkind 共組 ATON Pharma Inc. 公司，獲得哥倫比亞大學與 Sloan Kettering 專利權移轉以及贊助他們做第一期人體試驗。一期人體試驗結果顯示 SAHA 是個具有潛力的抗癌藥，使得許多藥廠想要買下 ATON 與 SAHA 的專利和數據。2004 年，Merck 收購 ATON 並完後後續的人體試驗，讓 SAHA 在 2006 年被美國 FDA 核准，2009 年被加拿大監管機構核准，2011 年被日本核准。SAHA 的成功啟發後面 HDAC 抑制劑的開發與研究。 {|class="wikitable" |- |DMSO||Acetamide||HMBA||化合物 1||SBHA||SAHA |- |[[File:Dimethylsulfoxid.svg|150px]] |[[File:Acetamide skeletal.svg|150px]] |[[File:Hexamethylene bis- acetamide.png|200px]] |[[File:Suberoyl-bis-N-methylamide.png|200px]] |[[File:Suberyol-bis-hydroxamicacid.png|200px]] |[[File:Vorinostat.svg|200px]] |} X 光晶體顯示（PDB 4LXZ）hydroxamic acid 基團與鋅離子螯合，phenyl 基團則躺在酵素的疏水表面 [[File:Interaction_of_vorinostat_with_HDAC2_active_site.svg]] =藥物合成= 此為其中一種方式，仍有需多合成方法 [[File:Synthesis of SAHA.png]] 2yzm0lfoip7s4mwyofvo22auk63gqrf 168547 168546 2022-08-25T09:05:48Z 葉智海 37921 /* 藥物合成 */ wikitext text/x-wiki *亦叫 Suberoylanilide hydroxamic acid（SAHA），商品名 Zolinza *是 hydroxamic acid 類第一個進入人體試驗的化合物，也是第一個上市的 HDAC 抑制劑 *結構中的 aniline 是 hydrophobic cap，hydroxamic acid 是 ZBG，中間六個碳即為 linker *2006 年 FDA 准許其用於經兩種全身性治療後仍出現進行性、持續性或復發性疾病表現之皮膚T細胞淋巴癌（Cutaneous T-cell lymphoma, CTCL），以及治療多發性骨髓瘤 =藥物結構= [[File:Vorinostat.svg]] =發展歷史= 1996 年時 Charlotte Friend 發現當老鼠 erythroleukemia cells （MELC）使用 280 mmolar 的 dimethyl sulfoxide （DMSO）處理時，會有大約 60% 的細胞經過細胞分化變成正常的紅血球，Paul Marks（時任人類遺傳學與醫學教授） 與 Ronald Breslow（當時時任哥倫比亞大學化學教授）認為這會是治療癌症的新切入點，但當然不能直接拿 DMSO 當藥品給人體使用，因此他們合作針對 DMSO 結構做修飾，Breslow 實驗室負責藥物化學研究與合成，Marks 負責生物活性測試 在他們初步合成的結構中，其中 N-methylacetamide 的活性是 DMSO 的五倍，但仍不夠變成人體用的藥物。因此他們決定合成兩個 acetamide 並在中間以 linker 連接，使藥物左右兩邊都具有藥效基團（如果發揮藥理作用的關鍵結構是 acetamide），或許能提高效價，合成一系列不同長度的 linker，其中六碳鏈長鏈的 hexamethylene bisacetamide （HMBA）的活性最優異，效價比單純的 acetamide 高十倍；除此之外，他們也合成 suberoyl-bis-N-methylamide（將 HMBA 的 amide 調換，化合物 1），活性也比 acetamide 高十倍；亦試過將三個甚至四個 acetamide 接在一起，但活性就沒有所提升。經過進一步的生物活性測試，他們決定拿 HMBA 做人體試驗。雖然 HMBA 在癌症患者中表現出預期療效，但所需的劑量太高。 後來他們猜想或許這些 compounds 的作用目標是酵素，也許是 metalloenzyme（筆者也不知道他們怎麼猜的）。如果這是對的，那代表 DMSO 還有他們合成的 compound 上的 amides 會與金屬交互作用，因此他們決定找一個更好的 metal ion binders。他們合成 suberoyl-bis-N-methylamide 的類似物但以 OH 基團取代原本的甲基，suberoyl-bis-hydroxamic acid（SBHA）。SBHA 的活性比 HMBA 優異，說明真的有可能這些 compounds 會與金屬離子鍵結。如果真是如此，它們推想目標物會剛好有兩個 metal ion 且相隔差不多六個碳的距離的可能性不大，也就是說 compounds 只需要一個藥效基團就好，不必左右兩邊都需要，所以他們把其中一個 OH 換成親脂性的 phenyl group，讓 phenyl 能跟蛋白質上親脂的區域交互作用，而合成出 SAHA。也果真，SAHA 在 MELC 細胞中抑制 HDAC 的效價比 SBHA 高約六倍，調整中間 linker 長度發現六個碳的活性是最適合，將 phenyl group 換成其他親脂基團能增加藥物與 HDAC 的鍵結能力但也增加藥物的毒性。經過進一步的生物活性測試與老鼠試驗，他們決定將 SAHA 推上人體試驗 2001 年，Marks, Breslow 與 Richard Rifkind 共組 ATON Pharma Inc. 公司，獲得哥倫比亞大學與 Sloan Kettering 專利權移轉以及贊助他們做第一期人體試驗。一期人體試驗結果顯示 SAHA 是個具有潛力的抗癌藥，使得許多藥廠想要買下 ATON 與 SAHA 的專利和數據。2004 年，Merck 收購 ATON 並完後後續的人體試驗，讓 SAHA 在 2006 年被美國 FDA 核准，2009 年被加拿大監管機構核准，2011 年被日本核准。SAHA 的成功啟發後面 HDAC 抑制劑的開發與研究。 {|class="wikitable" |- |DMSO||Acetamide||HMBA||化合物 1||SBHA||SAHA |- |[[File:Dimethylsulfoxid.svg|150px]] |[[File:Acetamide skeletal.svg|150px]] |[[File:Hexamethylene bis- acetamide.png|200px]] |[[File:Suberoyl-bis-N-methylamide.png|200px]] |[[File:Suberyol-bis-hydroxamicacid.png|200px]] |[[File:Vorinostat.svg|200px]] |} X 光晶體顯示（PDB 4LXZ）hydroxamic acid 基團與鋅離子螯合，phenyl 基團則躺在酵素的疏水表面 [[File:Interaction_of_vorinostat_with_HDAC2_active_site.svg]] =藥物合成= 此為其中一種方式，仍有需多合成方法 [[File:Synthesis of SAHA.png|900px]] kjc8m4ssriz68c77cg3xsf9p0skdjzk 0 32338 168540 2022-08-25T07:02:06Z 葉智海 37921 创建页面，内容为“=藥物結構= [[File:Trichostatin A.svg]] =藥物簡介= *又名 TSA *第一個被發現具有 hydroxamic acid 的 HDAC 抑制劑 *於 1976 年從 <i>Streptomyces hygroscopicus</i>，與 1987 年從 <i>Streptomyces platensis</i> No. 145 中鑑定與發現，一開始還沒發現其具有抑制 HDAC 活性，而是被當作可以對抗 <i> Trichophyton</i> 的抗真菌抗生素 *只有 R form 具有抑制 HDAC 活性 *對於 class I 與 II 有效，對 class I…” wikitext text/x-wiki =藥物結構= [[File:Trichostatin A.svg]] =藥物簡介= *又名 TSA *第一個被發現具有 hydroxamic acid 的 HDAC 抑制劑 *於 1976 年從 <i>Streptomyces hygroscopicus</i>，與 1987 年從 <i>Streptomyces platensis</i> No. 145 中鑑定與發現，一開始還沒發現其具有抑制 HDAC 活性，而是被當作可以對抗 <i> Trichophyton</i> 的抗真菌抗生素 *只有 R form 具有抑制 HDAC 活性 *對於 class I 與 II 有效，對 class IIII 沒藥理活性 *因其副作用大而沒有上市 1ikyg15kp6qhw7u8aog1g6vfg0x8fe2 0 32339 168550 2022-08-25T10:52:49Z 葉智海 37921 创建页面，内容为“*研究代號 PXD101，商品名 Beleodaq^® *為第二個被美國 FDA 核准的 HDAC 抑制劑 *2014 年被美國 FDA 核准用於復發型或不反應型 peripheral T-cell lymphoma =藥物結構= [[File:Belinostat.svg]] =發展歷史= 基於對 TSA 和 SAHA 的 SAR 研究，不管在 SAHA 上做什麼修飾都無法再提高藥效（同時不增加毒性），為了突破此一困境，TopoTarget 公司中 Paul W. Finn 的團隊打算以 sulfonami…” wikitext text/x-wiki *研究代號 PXD101，商品名 Beleodaq^® *為第二個被美國 FDA 核准的 HDAC 抑制劑 *2014 年被美國 FDA 核准用於復發型或不反應型 peripheral T-cell lymphoma =藥物結構= [[File:Belinostat.svg]] =發展歷史= 基於對 TSA 和 SAHA 的 SAR 研究，不管在 SAHA 上做什麼修飾都無法再提高藥效（同時不增加毒性），為了突破此一困境，TopoTarget 公司中 Paul W. Finn 的團隊打算以 sulfonamide 取代 SAHA 中的 amide 基團。他認為關鍵在 SAHA 以及他們合成的衍生物上 C-N-C(=O)-C 的二面角都是 180°，如果將其改成 sulfonamide，則二面角會落在 45° 到 90°，大大改變藥物的立體形狀，或許能產生新的 SAR 結果。鑑於此，他們合成出 AS1 與 AS2，然其活性比 SAHA 低。 接著他們將目標移至 SAHA 上的長碳鏈，欲將其修飾為結構更剛硬（不容易旋轉）的基團並合成一系列的化合物。結構最簡單的 S1 沒有活性，增加 linker 的長度對活性並沒有多大的改善 5knssrbm335yobs03vib2stcf2fcpga 168551 168550 2022-08-25T11:10:14Z 葉智海 37921 wikitext text/x-wiki *研究代號 PXD101，商品名 Beleodaq^® *為第二個被美國 FDA 核准的 HDAC 抑制劑 *2014 年被美國 FDA 核准用於復發型或不反應型 peripheral T-cell lymphoma =藥物結構= [[File:Belinostat.svg]] =發展歷史= 基於對 TSA 和 SAHA 的 SAR 研究，不管在 SAHA 上做什麼修飾都無法再提高藥效（同時不增加毒性），為了突破此一困境，TopoTarget 公司中 Paul W. Finn 的團隊打算以 sulfonamide 取代 SAHA 中的 amide 基團。他認為關鍵在 SAHA 以及他們合成的衍生物上 C-N-C(=O)-C 的二面角都是 180°，如果將其改成 sulfonamide，則二面角會落在 45° 到 90°，大大改變藥物的立體形狀，或許能產生新的 SAR 結果。鑑於此，他們合成出 AS1 與 AS2，然其活性比 SAHA 低。 接著他們將目標移至 SAHA 上的長碳鏈，欲將其修飾為結構更剛硬（不容易旋轉）的基團並合成一系列的化合物。結構最簡單的 S1 沒有活性，增加 linker 的長度對活性並沒有多大的改善 =藥物合成= [[File:Synthetic route of Belinostat.png|1000px]] 4p72d3v4oxut0o89l0q0x9t4yahn6vx