From f7ba813a54d6ff87fc5f359bcfcec8a19cc990f0 Mon Sep 17 00:00:00 2001
From: siddontang <siddontang@gmail.com>
Date: Wed, 15 Oct 2014 09:18:01 +0800
Subject: [PATCH] add sync2 package from vitess

---
 sync2/atomic.go      | 114 +++++++++++++++++++++++++++++++++++++++++++
 sync2/atomic_test.go |  32 ++++++++++++
 2 files changed, 146 insertions(+)
 create mode 100644 sync2/atomic.go
 create mode 100644 sync2/atomic_test.go

diff --git a/sync2/atomic.go b/sync2/atomic.go
new file mode 100644
index 0000000..909f3b1
--- /dev/null
+++ b/sync2/atomic.go
@@ -0,0 +1,114 @@
+// Copyright 2013, Google Inc. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package sync2
+
+import (
+	"sync"
+	"sync/atomic"
+	"time"
+)
+
+type AtomicInt32 int32
+
+func (i *AtomicInt32) Add(n int32) int32 {
+	return atomic.AddInt32((*int32)(i), n)
+}
+
+func (i *AtomicInt32) Set(n int32) {
+	atomic.StoreInt32((*int32)(i), n)
+}
+
+func (i *AtomicInt32) Get() int32 {
+	return atomic.LoadInt32((*int32)(i))
+}
+
+func (i *AtomicInt32) CompareAndSwap(oldval, newval int32) (swapped bool) {
+	return atomic.CompareAndSwapInt32((*int32)(i), oldval, newval)
+}
+
+type AtomicUint32 uint32
+
+func (i *AtomicUint32) Add(n uint32) uint32 {
+	return atomic.AddUint32((*uint32)(i), n)
+}
+
+func (i *AtomicUint32) Set(n uint32) {
+	atomic.StoreUint32((*uint32)(i), n)
+}
+
+func (i *AtomicUint32) Get() uint32 {
+	return atomic.LoadUint32((*uint32)(i))
+}
+
+func (i *AtomicUint32) CompareAndSwap(oldval, newval uint32) (swapped bool) {
+	return atomic.CompareAndSwapUint32((*uint32)(i), oldval, newval)
+}
+
+type AtomicInt64 int64
+
+func (i *AtomicInt64) Add(n int64) int64 {
+	return atomic.AddInt64((*int64)(i), n)
+}
+
+func (i *AtomicInt64) Set(n int64) {
+	atomic.StoreInt64((*int64)(i), n)
+}
+
+func (i *AtomicInt64) Get() int64 {
+	return atomic.LoadInt64((*int64)(i))
+}
+
+func (i *AtomicInt64) CompareAndSwap(oldval, newval int64) (swapped bool) {
+	return atomic.CompareAndSwapInt64((*int64)(i), oldval, newval)
+}
+
+type AtomicDuration int64
+
+func (d *AtomicDuration) Add(duration time.Duration) time.Duration {
+	return time.Duration(atomic.AddInt64((*int64)(d), int64(duration)))
+}
+
+func (d *AtomicDuration) Set(duration time.Duration) {
+	atomic.StoreInt64((*int64)(d), int64(duration))
+}
+
+func (d *AtomicDuration) Get() time.Duration {
+	return time.Duration(atomic.LoadInt64((*int64)(d)))
+}
+
+func (d *AtomicDuration) CompareAndSwap(oldval, newval time.Duration) (swapped bool) {
+	return atomic.CompareAndSwapInt64((*int64)(d), int64(oldval), int64(newval))
+}
+
+// AtomicString gives you atomic-style APIs for string, but
+// it's only a convenience wrapper that uses a mutex. So, it's
+// not as efficient as the rest of the atomic types.
+type AtomicString struct {
+	mu  sync.Mutex
+	str string
+}
+
+func (s *AtomicString) Set(str string) {
+	s.mu.Lock()
+	s.str = str
+	s.mu.Unlock()
+}
+
+func (s *AtomicString) Get() string {
+	s.mu.Lock()
+	str := s.str
+	s.mu.Unlock()
+	return str
+}
+
+func (s *AtomicString) CompareAndSwap(oldval, newval string) (swqpped bool) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	if s.str == oldval {
+		s.str = newval
+		return true
+	}
+	return false
+}
diff --git a/sync2/atomic_test.go b/sync2/atomic_test.go
new file mode 100644
index 0000000..7261159
--- /dev/null
+++ b/sync2/atomic_test.go
@@ -0,0 +1,32 @@
+// Copyright 2013, Google Inc. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package sync2
+
+import (
+	"testing"
+)
+
+func TestAtomicString(t *testing.T) {
+	var s AtomicString
+	if s.Get() != "" {
+		t.Errorf("want empty, got %s", s.Get())
+	}
+	s.Set("a")
+	if s.Get() != "a" {
+		t.Errorf("want a, got %s", s.Get())
+	}
+	if s.CompareAndSwap("b", "c") {
+		t.Errorf("want false, got true")
+	}
+	if s.Get() != "a" {
+		t.Errorf("want a, got %s", s.Get())
+	}
+	if !s.CompareAndSwap("a", "c") {
+		t.Errorf("want true, got false")
+	}
+	if s.Get() != "c" {
+		t.Errorf("want c, got %s", s.Get())
+	}
+}