多线程开发中，多用消息传递，少用锁

void TaskA() {}void TaskB(int v) {}
auto task_a = base::BindOnce(&TaskA);auto task_b = base::BindOnce(&TaskB, 42);

base::PostTask(FROM_HERE, base::BindOnce(&Task));

base::PostTask(    FROM_HERE, {base::TaskPriority::BEST_EFFORT, MayBlock()},    base::BindOnce(&Task));

class A { public:  A() = default;
  void DoSomething() {    task_runner_->PostTask(FROM_HERE, base::BindOnce(&A));  }
 private:  scoped_refptr<base::TaskRunner> task_runner_ =      base::CreateTaskRunner({base::TaskPriority::USER_VISIBLE});};

scoped_refptr<SequencedTaskRunner> sequenced_task_runner =    base::CreateSequencedTaskRunner(...);
// TaskB runs after TaskA completes.sequenced_task_runner->PostTask(FROM_HERE, base::BindOnce(&TaskA));sequenced_task_runner->PostTask(FROM_HERE, base::BindOnce(&TaskB));

// The task will run on the current (virtual) thread's default task queue.base::PostTask(FROM_HERE, {base::CurrentThread()}, base::BindOnce(&Task));

// The task will run on the current (virtual) thread's best effort queue.// NOTE only the Browser UI and Browser IO threads support task priority (for// now), other (virtual) threads will silently ignore traits used in combination// with `base::CurrentThread`.base::PostTask(FROM_HERE,               {base::CurrentThread(), base::TaskPriority::BEST_EFFORT},               base::BindOnce(&Task));

// The task will run after any task that has already been posted// to the SequencedTaskRunner to which the current task was posted// (in particular, it will run after the current task completes).// It is also guaranteed that it won’t run concurrently with any// task posted to that SequencedTaskRunner.base::GetContinuationTaskRunner()->    PostTask(FROM_HERE, base::BindOnce(&Task));

// The task will run on the current (virtual) thread's best effort queue.// NOTE only the Browser UI and Browser IO threads support task priority, other// (virtual) threads will silently ignore traits used in combination with// `base::CurrentThread`.base::PostTask(FROM_HERE,               {base::CurrentThread(), base::TaskPriority::BEST_EFFORT},               base::BindOnce(&Task));

// Tasks posted to |task_runner| will run on the current (virtual) thread's best// effort queue.auto task_runner = base::CreateSequencedTaskRunner(     {base::CurrentThread(), base::TaskPriority::BEST_EFFORT});

class A { public:  A() {    // Do not require accesses to be on the creation sequence.    DETACH_FROM_SEQUENCE(sequence_checker_);  }
  void AddValue(int v) {    // Check that all accesses are on the same sequence.    DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);    values_.push_back(v);}
 private:  SEQUENCE_CHECKER(sequence_checker_);
  // No lock required, because all accesses are on the  // same sequence.  std::vector<int> values_;};
A a;scoped_refptr<SequencedTaskRunner> task_runner_for_a = ...;task_runner_for_a->PostTask(FROM_HERE,                      base::BindOnce(&A::AddValue, base::Unretained(&a), 42));task_runner_for_a->PostTask(FROM_HERE,                      base::BindOnce(&A::AddValue, base::Unretained(&a), 27));
// Access from a different sequence causes a DCHECK failure.scoped_refptr<SequencedTaskRunner> other_task_runner = ...;other_task_runner->PostTask(FROM_HERE,                            base::BindOnce(&A::AddValue, base::Unretained(&a), 1));

base::PostTask(FROM_HERE, {content::BrowserThread::UI}, ...);
base::CreateSingleThreadTaskRunner({content::BrowserThread::IO})    ->PostTask(FROM_HERE, ...);

scoped_refptr<SingleThreadTaskRunner> single_thread_task_runner =    base::CreateSingleThreadTaskRunner(...);
// TaskB runs after TaskA completes. Both tasks run on the same thread.single_thread_task_runner->PostTask(FROM_HERE, base::BindOnce(&TaskA));single_thread_task_runner->PostTask(FROM_HERE, base::BindOnce(&TaskB));

// Task(A|B|C)UsingCOMSTA will run on the same COM STA thread.void TaskAUsingCOMSTA() {  // [ This runs on a COM STA thread. ]
  // Make COM STA calls.  // ...
  // Post another task to the current COM STA thread.  base::ThreadTaskRunnerHandle::Get()->PostTask(      FROM_HERE, base::BindOnce(&TaskCUsingCOMSTA));}void TaskBUsingCOMSTA() { }void TaskCUsingCOMSTA() { }auto com_sta_task_runner = base::CreateCOMSTATaskRunner(...);com_sta_task_runner->PostTask(FROM_HERE, base::BindOnce(&TaskAUsingCOMSTA));com_sta_task_runner->PostTask(FROM_HERE, base::BindOnce(&TaskBUsingCOMSTA));

// This task has no explicit TaskTraits. It cannot block. Its priority// is inherited from the calling context (e.g. if it is posted from// a BEST_EFFORT task, it will have a BEST_EFFORT priority). It will either// block shutdown or be skipped on shutdown.base::PostTask(FROM_HERE, base::BindOnce(...));
// This task has the highest priority. The thread pool will try to// run it before USER_VISIBLE and BEST_EFFORT tasks.base::PostTask(    FROM_HERE, {base::TaskPriority::USER_BLOCKING},    base::BindOnce(...));
// This task has the lowest priority and is allowed to block (e.g. it// can read a file from disk).base::PostTask(    FROM_HERE, {base::TaskPriority::BEST_EFFORT, base::MayBlock()},    base::BindOnce(...));
// This task blocks shutdown. The process won't exit before its// execution is complete.base::PostTask(    FROM_HERE, {base::TaskShutdownBehavior::BLOCK_SHUTDOWN},    base::BindOnce(...));
// This task will run on the Browser UI thread.base::PostTask(    FROM_HERE, {content::BrowserThread::UI},    base::BindOnce(...));
// This task will run on the current virtual thread (sequence).base::PostTask(    FROM_HERE, {base::CurrentThread()},    base::BindOnce(...));
// This task will run on the current virtual thread (sequence) with best effort// priority.base::PostTask(    FROM_HERE, {base::CurrentThread(), base::TaskPriority::BEST_EFFORT},    base::BindOnce(...));

// GetHistoryItemsFromDisk() may block for a long time.// AddHistoryItemsToOmniboxDropDown() updates the UI and therefore must// be called on the main thread.AddHistoryItemsToOmniboxDropdown(GetHistoryItemsFromDisk("keyword"));

base::PostTaskAndReplyWithResult(    FROM_HERE, {base::MayBlock()},    base::BindOnce(&GetHistoryItemsFromDisk, "keyword"),    base::BindOnce(&AddHistoryItemsToOmniboxDropdown));

base::PostDelayedTask(  FROM_HERE, {base::TaskPriority::BEST_EFFORT}, base::BindOnce(&Task),  base::TimeDelta::FromHours(1));
scoped_refptr<base::SequencedTaskRunner> task_runner =    base::CreateSequencedTaskRunner({base::TaskPriority::BEST_EFFORT});task_runner->PostDelayedTask(    FROM_HERE, base::BindOnce(&Task), base::TimeDelta::FromHours(1));

class A { public:  ~A() {    // The timer is stopped automatically when it is deleted.  }  void StartDoingStuff() {    timer_.Start(FROM_HERE, TimeDelta::FromSeconds(1),                 this, &MyClass::DoStuff);  }  void StopDoingStuff() {    timer_.Stop();  } private:  void DoStuff() {    // This method is called every second on the sequence that invoked    // StartDoingStuff().  }  base::RepeatingTimer timer_;};

int Compute() { … }
class A { public:  void ComputeAndStore() {    // Schedule a call to Compute() in a thread pool followed by    // a call to A::Store() on the current sequence. The call to    // A::Store() is canceled when |weak_ptr_factory_| is destroyed.    // (guarantees that |this| will not be used-after-free).    base::PostTaskAndReplyWithResult(        FROM_HERE, base::BindOnce(&Compute),        base::BindOnce(&A::Store, weak_ptr_factory_.GetWeakPtr()));  }
 private:  void Store(int value) { value_ = value; }
  int value_;  base::WeakPtrFactory<A> weak_ptr_factory_{this};};

auto task_runner = base::CreateTaskRunner({base::ThreadPool()});base::CancelableTaskTracker cancelable_task_tracker;cancelable_task_tracker.PostTask(task_runner.get(), FROM_HERE,                                 base::DoNothing());// Cancels Task(), only if it hasn't already started running.cancelable_task_tracker.TryCancelAll();

class MyTest : public testing::Test { public:  // ... protected:   base::test::TaskEnvironment task_environment_;};
TEST(MyTest, MyTest) {  base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, base::BindOnce(&A));  base::SequencedTaskRunnerHandle::Get()->PostTask(FROM_HERE,                                                   base::BindOnce(&B));  base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(      FROM_HERE, base::BindOnce(&C), base::TimeDelta::Max());
  // This runs the (Thread|Sequenced)TaskRunnerHandle queue until it is empty.  // Delayed tasks are not added to the queue until they are ripe for execution.  base::RunLoop().RunUntilIdle();  // A and B have been executed. C is not ripe for execution yet.
  base::RunLoop run_loop;  base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, base::BindOnce(&D));  base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, run_loop.QuitClosure());  base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, base::BindOnce(&E));
  // This runs the (Thread|Sequenced)TaskRunnerHandle queue until QuitClosure is  // invoked.  run_loop.Run();  // D and run_loop.QuitClosure() have been executed. E is still in the queue.
  // Tasks posted to thread pool run asynchronously as they are posted.  base::PostTask(FROM_HERE, {base::ThreadPool()}, base::BindOnce(&F));  auto task_runner =      base::CreateSequencedTaskRunner({base::ThreadPool()});  task_runner->PostTask(FROM_HERE, base::BindOnce(&G));
  // To block until all tasks posted to thread pool are done running:  base::ThreadPoolInstance::Get()->FlushForTesting();  // F and G have been executed.
  base::PostTaskAndReplyWithResult(      FROM_HERE, base::TaskTrait(),      base::BindOnce(&H), base::BindOnce(&I));
  // This runs the (Thread|Sequenced)TaskRunnerHandle queue until both the  // (Thread|Sequenced)TaskRunnerHandle queue and the TaskSchedule queue are  // empty:  task_environment_.RunUntilIdle();  // E, H, I have been executed.}

// This initializes and starts ThreadPoolInstance with default params.base::ThreadPoolInstance::CreateAndStartWithDefaultParams(“process_name”);// The base/task/post_task.h API can now be used with base::ThreadPool trait.// Tasks will be // scheduled as they are posted.
// This initializes ThreadPoolInstance.base::ThreadPoolInstance::Create(“process_name”);// The base/task/post_task.h API can now be used with base::ThreadPool trait. No// threads will be created and no tasks will be scheduled until after Start() is// called.base::ThreadPoolInstance::Get()->Start(params);// ThreadPool can now create threads and schedule tasks.

base::ThreadPoolInstance::Get()->Shutdown();// Tasks posted with TaskShutdownBehavior::BLOCK_SHUTDOWN and// tasks posted with TaskShutdownBehavior::SKIP_ON_SHUTDOWN that// have started to run before the Shutdown() call have now completed their// execution. Tasks posted with// TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN may still be// running.

class Foo { public:
  // Overrides |background_task_runner_| in tests.  void SetBackgroundTaskRunnerForTesting(      scoped_refptr<base::SequencedTaskRunner> background_task_runner) {    background_task_runner_ = std::move(background_task_runner);  }
 private:  scoped_refptr<base::SequencedTaskRunner> background_task_runner_ =      base::CreateSequencedTaskRunner(          {base::MayBlock(), base::TaskPriority::BEST_EFFORT});}

// The task will run on the current thread in the future.base::ThreadTaskRunnerHandle::Get()->PostTask(    FROM_HERE, base::BindOnce(&Task));

// The task will run after any task that has already been posted// to the SequencedTaskRunner to which the current task was posted// (in particular, it will run after the current task completes).// It is also guaranteed that it won’t run concurrently with any// task posted to that SequencedTaskRunner.base::SequencedTaskRunnerHandle::Get()->    PostTask(FROM_HERE, base::BindOnce(&Task));

// |Foo| just refers to |cb| but doesn't store it nor consume it.bool Foo(const base::OnceCallback<void(int)>& cb) {  return cb.is_null();}
// |Bar| takes the ownership of |cb| and stores |cb| into |g_cb|.base::RepeatingCallback<void(int)> g_cb;void Bar(base::RepeatingCallback<void(int)> cb) {  g_cb = std::move(cb);}
// |Baz| takes the ownership of |cb| and consumes |cb| by Run().void Baz(base::OnceCallback<void(int)> cb) {  std::move(cb).Run(42);}
// |Qux| takes the ownership of |cb| and transfers ownership to PostTask(),// which also takes the ownership of |cb|.void Qux(base::RepeatingCallback<void(int)> cb) {  PostTask(FROM_HERE, base::BindOnce(cb, 42));  PostTask(FROM_HERE, base::BindOnce(std::move(cb), 43));}

int Return5() { return 5; }base::OnceCallback<int()> func_cb = base::BindOnce(&Return5);LOG(INFO) << std::move(func_cb).Run();  // Prints 5.

int Return5() { return 5; }base::RepeatingCallback<int()> func_cb = base::BindRepeating(&Return5);LOG(INFO) << func_cb.Run();  // Prints 5.

base::Callback<int()> lambda_cb = base::Bind([] { return 4; });LOG(INFO) << lambda_cb.Run();  // Print 4.
base::OnceCallback<int()> lambda_cb2 = base::BindOnce([] { return 3; });LOG(INFO) << std::move(lambda_cb2).Run();  // Print 3.

#include "base/test/bind_test_util.h"
int i = 2;base::Callback<void()> lambda_cb = base::BindLambdaForTesting([&]() { i++; });lambda_cb.Run();LOG(INFO) << i;  // Print 3;

class Ref : public base::RefCountedThreadSafe<Ref> { public:  int Foo() { return 3; }};scoped_refptr<Ref> ref = new Ref();base::Callback<void()> ref_cb = base::Bind(&Ref::Foo, ref);LOG(INFO) << ref_cb.Run();  // Prints out 3.

void DoSomething(const base::Callback<void(int, std::string)>& callback) {  callback.Run(5, "hello");}
void DoSomethingOther(base::OnceCallback<void(int, std::string)> callback) {  std::move(callback).Run(5, "hello");}

void DoSomething(const base::RepeatingCallback<double(double)>& callback) {  double myresult = callback.Run(3.14159);  myresult += callback.Run(2.71828);}

void Foo::RunCallback() {  std::move(&foo_deleter_callback_).Run();}

using MyCallback = base::OnceCallback<void(bool arg)>;void MyFunction(MyCallback callback) {  std::move(callback).Run(true);  // Uh oh...}...MyFunction(MyCallback());  // ...this will crash when Run()!

...MyFunction(base::DoNothing());  // Can be Run(), will no-op

// Binds |foo_ptr| to a no-op OnceCallback takes a scoped_refptr<Foo>.// ANTIPATTERN WARNING: This should likely be changed to ReleaseSoon()!base::Bind(base::DoNothing::Once<scoped_refptr<Foo>>(), foo_ptr);

void MyFunc(int i, const std::string& str) {}base::Callback<void(int, const std::string&)> cb = base::Bind(&MyFunc);cb.Run(23, "hello, world");

void MyFunc(int i, const std::string& str) {}base::Callback<void()> cb = base::Bind(&MyFunc, 23, "hello world");cb.Run();

base::Closure cb = base::Bind(&MyFunc, 23, "hello world");

base::Closure cb = base::Bind(&MyClass::MyFunc, this, 23, "hello world");

void ReadIntFromFile(const std::string& filename,                     base::OnceCallback<void(int)> on_read);
void DisplayIntWithPrefix(const std::string& prefix, int result) {  LOG(INFO) << prefix << result;}
void AnotherFunc(const std::string& file) {  ReadIntFromFile(file, base::BindOnce(&DisplayIntWithPrefix, "MyPrefix: "));};

std::vector<int> v = {1, 2, 3};// |v| is moved into the internal storage without copy.base::Bind(&Foo, std::move(v));

// The vector is moved into the internal storage without copy.base::Bind(&Foo, std::vector<int>({1, 2, 3}));

void Foo(std::unique_ptr<int>) {}auto p = std::make_unique<int>(42);
// |p| is moved into the internal storage of Bind(), and moved out to |Foo|.base::BindOnce(&Foo, std::move(p));base::BindRepeating(&Foo, base::Passed(&p)); // Ok, but subtle.base::BindRepeating(&Foo, base::Passed(std::move(p))); // Ok, but subtle.

base::Bind(&MyClass::Foo, weak_this_);

class MyClass {public:  MyClass() {    weak_this_ = weak_factory_.GetWeakPtr();  }private:  base::WeakPtr<MyClass> weak_this_;  // MyClass member variables go here.  base::WeakPtrFactory<MyClass> weak_factory_{this};};

base::Bind(&MyClass::Foo, base::Unretained(this));

MyClass* myclass = new MyClass;base::Bind(&MyClass::Foo, base::Owned(myclass));

std::unique_ptr<MyClass> myclass(new MyClass);base::Bind(&MyClass::Foo, std::move(myclass));

int DoSomething(int arg) { cout << arg << endl; }base::Callback<void(int)> cb =    base::Bind(IgnoreResult(&DoSomething));

void Foo(int* arg) { cout << *arg << endl; }int* pn = new int(1);base::Closure foo_callback = base::Bind(&foo, base::Owned(pn));

void TakesOwnership(std::unique_ptr<Foo> arg) {}auto f = std::make_unique<Foo>();// f becomes null during the following call.base::OnceClosure cb = base::BindOnce(&TakesOwnership, std::move(f));

void TakesOneRef(scoped_refptr<Foo> arg) {}scoped_refptr<Foo> f(new Foo);base::Closure cb = base::Bind(&TakesOneRef, f);

void DontTakeRef(Foo* arg) {}scoped_refptr<Foo> f(new Foo);base::Closure cb = base::Bind(&DontTakeRef, base::RetainedRef(f));

void foo(const int& arg) { printf("%d %p\n", arg, &arg); }int n = 1;base::Closure has_copy = base::Bind(&foo, n);base::Closure has_ref = base::Bind(&foo, std::cref(n));n = 2;foo(n);                        // Prints "2 0xaaaaaaaaaaaa"has_copy.Run();                // Prints "1 0xbbbbbbbbbbbb"has_ref.Run();                 // Prints "2 0xaaaaaaaaaaaa"

namespace base {
template <typename Receiver>struct IsWeakReceiver {  static constexpr bool value = false;};
template <typename Obj>struct UnwrapTraits {  template <typename T>  T&& Unwrap(T&& obj) {    return std::forward<T>(obj);  }};
}  // namespace base

void Foo(const char* ptr);void Bar(char* ptr);base::Bind(&Foo, "test");base::Bind(&Bar, "test");  // This fails because ptr is not const.

void Foo(int x, bool y);base::Bind(&Foo, _1, false); // _1 is a placeholder.