Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний
Please open Telegram to view this post
VIEW IN TELEGRAM
Используется для обеспечения эксклюзивного доступа к общему ресурсу. Когда мьютекс заблокирован одной горутиной, все другие горутины, пытающиеся заблокировать этот же мьютекс, будут заблокированы до тех пор, пока первый мьютекс не будет разблокирован.
Блокирует мьютекс. Если мьютекс уже заблокирован, текущая горутина блокируется до тех пор, пока мьютекс не будет освобожден.
Разблокирует мьютекс. Если есть другие горутины, ожидающие блокировки этого мьютекса, одна из них будет разблокирована и сможет продолжить выполнение.
package main
import (
"fmt"
"sync"
)
var mu sync.Mutex
var counter int
func increment() {
mu.Lock()
counter++
mu.Unlock()
}
func main() {
var wg sync.WaitGroup
for i := 0; i < 10; i++ {
wg.Add(1)
go func() {
defer wg.Done()
increment()
}()
}
wg.Wait()
fmt.Println("Counter:", counter)
}
sync.RWMutex (мьютекс для чтения и записи) предоставляет два типа блокировок:Для чтения (
RLock): Позволяет нескольким горутинам одновременно читать данные.Для записи (
Lock): Обеспечивает эксклюзивный доступ для записи, блокируя все другие операции чтения и записи.RLock()Блокирует мьютекс для чтения. Если мьютекс уже заблокирован для записи, текущая горутина блокируется до тех пор, пока мьютекс не будет освобожден.
RUnlock()Разблокирует мьютекс для чтения.
Lock()Блокирует мьютекс для записи. Если мьютекс заблокирован для чтения или записи, текущая горутина блокируется до тех пор, пока мьютекс не будет освобожден.
Unlock()Разблокирует мьютекс для записи.
package main
import (
"fmt"
"sync"
)
var rwMu sync.RWMutex
var counter int
func readCounter() int {
rwMu.RLock()
defer rwMu.RUnlock()
return counter
}
func increment() {
rwMu.Lock()
counter++
rwMu.Unlock()
}
func main() {
var wg sync.WaitGroup
// Запуск нескольких горутин для чтения
for i := 0; i < 5; i++ {
wg.Add(1)
go func() {
defer wg.Done()
fmt.Println("Read Counter:", readCounter())
}()
}
// Запуск нескольких горутин для записи
for i := 0; i < 5; i++ {
wg.Add(1)
go func() {
defer wg.Done()
increment()
}()
}
wg.Wait()
fmt.Println("Final Counter:", counter)
}
sync.Mutex: Блокирует доступ ко всем операциям (чтение и запись).sync.RWMutex: Позволяет одновременное чтение, но блокирует доступ при записи.sync.Mutex: Подходит для сценариев с частыми операциями записи или равномерным распределением чтений и записей.sync.RWMutex: Подходит для сценариев с частыми операциями чтения и редкими операциями записи.sync.Mutex: Используйте, когда необходимо обеспечить эксклюзивный доступ к ресурсу без различий между операциями чтения и записи.sync.RWMutex: Используйте, когда операции чтения преобладают над операциями записи, чтобы повысить производительность за счет одновременного чтения.Ставь 👍 и забирай 📚 Базу знаний
Please open Telegram to view this post
VIEW IN TELEGRAM
Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний
Please open Telegram to view this post
VIEW IN TELEGRAM
Они способствуют созданию кода, который является более надежным, поддерживаемым и расширяемым.
Написание тестов помогает обнаружить ошибки и дефекты на ранних стадиях разработки. Регулярное тестирование кода обеспечивает его корректное функционирование и уменьшает количество ошибок.
Тесты служат документацией, показывая, как должен работать код. Это облегчает понимание кода новым разработчикам и помогает избежать регрессий при внесении изменений.
Для упрощения тестирования разработчики разбивают код на небольшие, легко тестируемые модули и функции. Это приводит к более чистому и структурированному коду.
Для облегчения тестирования функции и модули должны иметь четко определенные интерфейсы и зависимости. Это приводит к лучшему дизайну API и модулей.
Тесты помогают выявить излишне сложные и трудно тестируемые участки кода, что стимулирует рефакторинг и упрощение кода.
Это методология разработки, при которой тесты пишутся перед написанием функционального кода. Этот подход оказывает дополнительное влияние на организацию кода:
TDD способствует разработке кода малыми итерациями. Каждый цикл включает написание теста, написание кода для его прохождения и рефакторинг. Это улучшает качество кода и позволяет быстро обнаруживать ошибки
Пишутся только те функции, которые необходимы для прохождения тестов, что помогает сосредоточиться на текущих требованиях и избежать излишней функциональности.
TDD стимулирует создание кода с хорошим дизайном, так как разработчики изначально проектируют код таким образом, чтобы он был легко тестируемым.
Тесты, написанные в рамках TDD, служат живой документацией, описывающей, как должен работать код. Это облегчает понимание кода другими разработчиками и упрощает процесс внесения изменений.
package main
import "testing"
func TestAdd(t *testing.T) {
result := Add(2, 3)
if result != 5 {
t.Errorf("Expected 5, but got %d", result)
}
}
package main
func Add(a, b int) int {
return a + b
}
В данном случае рефакторинг не требуется, так как код уже является простым и понятным.
Ставь 👍 и забирай 📚 Базу знаний
Please open Telegram to view this post
VIEW IN TELEGRAM
Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний
Please open Telegram to view this post
VIEW IN TELEGRAM
Алгоритмы обеспечивают доступ к общим ресурсам в многопоточной среде без использования традиционных блокирующих механизмов, таких как мьютексы. Основная идея заключается в том, что хотя один или несколько потоков могут быть временно приостановлены, по крайней мере один поток всегда будет прогрессировать. Это достигается с помощью атомарных операций, которые гарантируют целостность данных и предотвращают состояния гонки.
Выполняются полностью или не выполняются вообще, без промежуточных состояний. Они обеспечивают безопасность и целостность данных в многопоточной среде.
Compare-And-Swap (CAS)Одна из самых распространенных атомарных операций, которая сравнивает текущее значение переменной с ожидаемым и, если они совпадают, обновляет переменную новым значением.
Fetch-And-Add: Атомарно увеличивает значение переменной и возвращает старое значение.
Lock-free алгоритмы стараются минимизировать критические секции, то есть участки кода, где потоки взаимодействуют с общими данными, чтобы уменьшить вероятность блокировок и состояний гонки.
В lock-free алгоритмах не используются традиционные механизмы блокировки, такие как мьютексы, что исключает вероятность взаимных блокировок (deadlocks).
package main
import (
"fmt"
"sync/atomic"
"unsafe"
)
type Node struct {
value int
next *Node
}
type Stack struct {
head *Node
}
func (s *Stack) Push(value int) {
newNode := &Node{value: value}
for {
oldHead := s.head
newNode.next = oldHead
if atomic.CompareAndSwapPointer((*unsafe.Pointer)(unsafe.Pointer(&s.head)), unsafe.Pointer(oldHead), unsafe.Pointer(newNode)) {
break
}
}
}
func (s *Stack) Pop() (int, bool) {
for {
oldHead := s.head
if oldHead == nil {
return 0, false
}
newHead := oldHead.next
if atomic.CompareAndSwapPointer((*unsafe.Pointer)(unsafe.Pointer(&s.head)), unsafe.Pointer(oldHead), unsafe.Pointer(newHead)) {
return oldHead.value, true
}
}
}
func main() {
stack := &Stack{}
stack.Push(1)
stack.Push(2)
value, ok := stack.Pop()
if ok {
fmt.Println("Popped:", value)
} else {
fmt.Println("Stack is empty")
}
}
Потоки не блокируют друг друга, что исключает проблему deadlock.
Параллельный доступ к данным без блокировок улучшает производительность, особенно на многоядерных системах.
Избегание блокировок снижает накладные расходы, связанные с контекстными переключениями и синхронизацией.
Lock-free алгоритмы сложны в реализации и отладке из-за необходимости работы с атомарными операциями и контроля состояний гонки.
Не все языки и платформы предоставляют полную поддержку атомарных операций.
Частые повторные попытки атомарных операций могут ухудшить масштабируемость в некоторых сценариях.
Ставь 👍 и забирай 📚 Базу знаний
Please open Telegram to view this post
VIEW IN TELEGRAM
Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний
Please open Telegram to view this post
VIEW IN TELEGRAM
Этот подход обеспечивает ряд преимуществ, которые способствуют улучшению качества кода, его поддерживаемости и соответствию требованиям.
Написание тестов перед кодом помогает разработчикам четко определить требования к функции или модулю. Тесты выступают в роли спецификации, описывающей, как должен работать код. Это помогает избежать недоразумений и гарантирует, что все требования учтены с самого начала.
TDD заставляет разработчиков сосредоточиться на минимальной функциональности, необходимой для прохождения тестов. Это предотвращает избыточное проектирование и разработку ненужных функций. Каждый тест фокусируется на одном аспекте функциональности, что помогает создавать чистый и целенаправленный код.
Написание тестов перед кодом стимулирует создание модульного и хорошо структурированного кода. Поскольку тесты проверяют небольшие и изолированные части кода, это побуждает разработчиков разделять большие задачи на более мелкие и управляемые модули, что улучшает дизайн и архитектуру системы.
Тесты, написанные перед кодом, обеспечивают немедленную обратную связь. Если код не проходит тест, это означает, что он не соответствует требованиям. Это позволяет разработчикам быстро обнаруживать и исправлять ошибки, повышая уверенность в корректности кода.
Тесты служат живой документацией кода. Они показывают, как должен работать код и какие случаи использования поддерживаются. Это облегчает понимание кода другим разработчикам и упрощает его поддержку в будущем.
Постоянное написание тестов и их прохождение помогает поддерживать высокое качество кода. Тесты выявляют дефекты на ранних стадиях разработки и обеспечивают, что новые изменения не нарушают существующую функциональность.
package main
import "testing"
func TestAdd(t *testing.T) {
result := Add(2, 3)
if result != 5 {
t.Errorf("Expected 5, but got %d", result)
}
}
На этом этапе тест не пройдет, так как функция
Add еще не реализована.package main
func Add(a, b int) int {
return a + b
}
Теперь тест пройдет, так как функция
Add реализована корректно.При необходимости выполняется рефакторинг кода для улучшения его структуры, при этом тесты продолжают проходить, что гарантирует сохранение функциональности.
Ставь 👍 и забирай 📚 Базу знаний
Please open Telegram to view this post
VIEW IN TELEGRAM
Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний
Please open Telegram to view this post
VIEW IN TELEGRAM
Модули сильно зависят друг от друга. Изменения в одном модуле требуют изменений в других.
Модуль выполняет несколько различных задач. Трудно поддерживать и изменять код.
Содержат слишком много логики. Длинные и сложные для понимания.
Один и тот же код повторяется в нескольких местах.
Код не покрыт тестами. Трудно проверять корректность.
Имена не отражают назначение. Трудно понять код.
Логика кода трудна для понимания. Много условных операторов.
Нет комментариев и документации.
Высокое сцепление:
type UserService struct {
userRepository UserRepository
emailService EmailService
}Низкая связанность:
type UserService struct {
db Database
businessLogic BusinessLogic
notificationService NotificationService
}Большие функции и классы:
func ProcessData() {
// Много строк кода
}Дублирование кода:
func CalculateSum(a, b int) int {
return a + b
}
func AddNumbers(x, y int) int {
return x + y
}Неразборчивые имена:
func DoSomething(x int) int {
return x * 2
}Ставь 👍 и забирай 📚 Базу знаний
Please open Telegram to view this post
VIEW IN TELEGRAM
Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний
Please open Telegram to view this post
VIEW IN TELEGRAM
Включает различные методы, позволяющие процессам обмениваться данными и сигналами.
Однонаправленные каналы между родительским и дочерним процессами. Обмен данными между произвольными процессами.
Обмен сообщениями через общую очередь. System V, POSIX message queues.
Совместное использование памяти для обмена данными. POSIX (
shm_open), System V shared memory.Синхронизация доступа к ресурсам. POSIX (
sem_open), System V semaphores.Обмен данными через сетевые соединения. Unix domain sockets, TCP/UDP.
Отправка и обработка событий.
kill(), signal() в Unix.Обмен данными через файлы или базы данных. Файлы, SQLite.
Каналы (Pipes)
package main
import (
"fmt"
"os"
"syscall"
)
func main() {
fd := make([]int, 2)
if err := syscall.Pipe(fd); err != nil {
fmt.Println("Ошибка создания канала:", err)
os.Exit(1)
}
pid, err := syscall.ForkExec("", nil, &syscall.ProcAttr{Files: []uintptr{uintptr(fd[0]), uintptr(fd[1]), uintptr(os.Stderr.Fd())}})
if err != nil {
fmt.Println("Ошибка создания процесса:", err)
os.Exit(1)
}
if pid == 0 { // Child process
syscall.Close(fd[0])
_, err := syscall.Write(fd[1], []byte("Hello"))
if err != nil {
fmt.Println("Ошибка записи в канал:", err)
}
syscall.Close(fd[1])
} else { // Parent process
buffer := make([]byte, 5)
syscall.Close(fd[1])
_, err := syscall.Read(fd[0], buffer)
if err != nil {
fmt.Println("Ошибка чтения из канала:", err)
}
syscall.Close(fd[0])
fmt.Printf("Получено: %s\n", buffer)
}
}
Общая память (Shared Memory)
package main
import (
"fmt"
"os"
"syscall"
)
func main() {
// Создание сегмента разделяемой памяти
segmentID, _, err := syscall.Syscall(syscall.SYS_SHMGET, uintptr(syscall.IPC_PRIVATE), uintptr(4), uintptr(syscall.S_IRUSR|syscall.S_IWUSR))
if err != 0 {
fmt.Println("Ошибка создания сегмента разделяемой памяти:", err)
os.Exit(1)
}
// Присоединение к сегменту
sharedMemory, _, err := syscall.Syscall(syscall.SYS_SHMAT, segmentID, 0, 0)
if err != 0 {
fmt.Println("Ошибка присоединения к разделяемой пам
Ставь 👍 и забирай 📚 Базу знаний
Please open Telegram to view this post
VIEW IN TELEGRAM
Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний
Please open Telegram to view this post
VIEW IN TELEGRAM
Позволяют синхронизировать доступ к ограниченным ресурсам, в данном случае — к оперативной памяти. Семафор может быть инициализирован значением 1, указывая, что доступен только один слот памяти. Когда один из процессов захватывает семафор, другой процесс будет заблокирован, пока семафор не освободится.
package main
import (
"fmt"
"sync"
"time"
)
var mutex sync.Mutex
func process(id int) {
mutex.Lock() // Захват семафора
fmt.Printf("Process %d: Accessing memory\n", id)
time.Sleep(2 * time.Second) // Имитируем доступ к памяти
fmt.Printf("Process %d: Releasing memory\n", id)
mutex.Unlock() // Освобождение семафора
}
func main() {
var wg sync.WaitGroup
wg.Add(2)
go func() {
defer wg.Done()
process(1)
}()
go func() {
defer wg.Done()
process(2)
}()
wg.Wait()
}
Обеспечивают эксклюзивный доступ к критической секции. Один процесс захватывает мьютекс перед доступом к памяти, другой процесс будет заблокирован до освобождения мьютекса.
package main
import (
"fmt"
"sync"
"time"
)
var mutex sync.Mutex
func process(id int) {
mutex.Lock() // Захват мьютекса
fmt.Printf("Process %d: Accessing memory\n", id)
time.Sleep(2 * time.Second) // Имитируем доступ к памяти
fmt.Printf("Process %d: Releasing memory\n", id)
mutex.Unlock() // Освобождение мьютекса
}
func main() {
var wg sync.WaitGroup
wg.Add(2)
go func() {
defer wg.Done()
process(1)
}()
go func() {
defer wg.Done()
process(2)
}()
wg.Wait()
}
Может быть использована для координации доступа к памяти, позволяя процессам обмениваться сообщениями о доступности ресурса.
package main
import (
"fmt"
"time"
)
type Message struct {
processID int
}
func accessMemory(processID int) {
fmt.Printf("Process %d: Accessing memory\n", processID)
time.Sleep(2 * time.Second) // Имитируем доступ к памяти
fmt.Printf("Process %d: Releasing memory\n", processID)
}
func main() {
msgChannel := make(chan Message)
go func() {
// "Дочерний" процесс
message := Message{processID: 1}
msgChannel <- message
msg := <-msgChannel
accessMemory(msg.processID)
}()
go func() {
// "Родительский" процесс
message := Message{processID: 2}
msgChannel <- message
msg := <-msgChannel
accessMemory(msg.processID)
}()
msg := <-msgChannel // Получаем сообщение от дочернего процесса
msgChannel <- msg // Отправляем обратно для завершения доступа
msg = <-msgChannel // Получаем сообщение от родительского процесса
msgChannel <- msg // Отправляем обратно для завершения доступа
time.Sleep(3 * time.Second) // Подождем завершения горутин
}
Ставь 👍 и забирай 📚 Базу знаний
Please open Telegram to view this post
VIEW IN TELEGRAM
Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний
Please open Telegram to view this post
VIEW IN TELEGRAM
Объектно-ориентированное программирование (ООП) в Go и C# реализовано с использованием различных подходов и парадигм, отражающих философию и дизайн каждого языка.
Используются структуры (
struct).type Person struct {
Name string
Age int
}
func (p *Person) Greet() {
fmt.Printf("Hello, my name is %s\n", p.Name)
}Используется композиция вместо наследования.
type Employee struct {
Person
Position string
}Модификаторы доступа на уровне пакета (экспортируемые и неэкспортируемые поля).
type Person struct {
name string // неэкспортируемое поле
Age int // экспортируемое поле
}Реализуется через интерфейсы.
type Greeter interface {
Greet()
}
type Person struct {
Name string
}
func (p *Person) Greet() {
fmt.Printf("Hello, my name is %s\n", p.Name)
}Используются классы.
public class Person {
public string Name { get; set; }
public int Age { get; set; }
public void Greet() {
Console.WriteLine($"Hello, my name is {Name}");
}
}Поддерживается классическое наследование.
public class Employee : Person {
public string Position { get; set; }
}Модификаторы доступа (
public, private, protected).public class Person {
private string name;
public int Age { get; set; }
}Через виртуальные методы и интерфейсы.
public class Person {
public virtual void Greet() {
Console.WriteLine("Hello!");
}
}
public class Employee : Person {
public override void Greet() {
Console.WriteLine("Hello, I am an employee!");
}
}Ставь 👍 и забирай 📚 Базу знаний
Please open Telegram to view this post
VIEW IN TELEGRAM
Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний
Please open Telegram to view this post
VIEW IN TELEGRAM
Объектно-ориентированная модель отличается от традиционных ООП-языков, таких как C# или Java. Нет классов и наследования в привычном понимании. Вместо этого используются структуры (structs) и интерфейсы для реализации основных принципов ООП: инкапсуляции, композиции и полиморфизма.
Служат аналогом классов. Они позволяют объединять данные в логически связанные группы.
type Person struct {
Name string
Age int
}Могут быть определены для структур, что позволяет связывать функции с типами.
func (p Person) Greet() {
fmt.Printf("Hello, my name is %s\n", p.Name)
}Достигается через модификаторы доступа на уровне пакета. Поля и методы, начинающиеся с заглавной буквы, экспортируемые (public), остальные — нет (private).
type Person struct {
name string // неэкспортируемое поле
Age int // экспортируемое поле
}Go не поддерживает классическое наследование. Вместо этого используется композиция для включения функциональности одного типа в другой.
type Employee struct {
Person
Position string
}Используются для определения поведения. Типы могут реализовывать интерфейсы неявно, просто предоставляя методы, указанные в интерфейсе.
type Greeter interface {
Greet()
}
func SayHello(g Greeter) {
g.Greet()
}
type Person struct {
Name string
}
func (p Person) Greet() {
fmt.Printf("Hello, my name is %s\n", p.Name)
}
func main() {
p := Person{Name: "John"}
SayHello(p)
}Достигается через интерфейсы. Любой тип, который реализует интерфейс, может быть использован вместо него.
type Greeter interface {
Greet()
}
func SayHello(g Greeter) {
g.Greet()
}
type Robot struct {
ID string
}
func (r Robot) Greet() {
fmt.Printf("Greetings, I am robot %s\n", r.ID)
}
func main() {
p := Person{Name: "John"}
r := Robot{ID: "XJ-9"}
SayHello(p)
SayHello(r)
}Ставь 👍 и забирай 📚 Базу знаний
Please open Telegram to view this post
VIEW IN TELEGRAM
Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний
Please open Telegram to view this post
VIEW IN TELEGRAM
Реализуют разные концепции и обладают различными характеристиками. Встраивание используется для композиции и повторного использования кода, а не для создания иерархий классов, как в традиционном наследовании.
Наследование: В языках с традиционным ООП, таких как C# или Java, наследование создает иерархии классов, где подклассы наследуют свойства и методы суперклассов. Подклассы могут переопределять методы суперклассов (полиморфизм) и добавлять новые методы.
Встраивание: Go не поддерживает иерархии классов. Встраивание позволяет включать типы в другие типы без создания строгих иерархий. Встраивание не создает отношений "is-a" (как в наследовании), а реализует отношения "has-a". Здесь
Employee наследует свойства и методы Person.public class Person {
public string Name { get; set; }
public void Greet() {
Console.WriteLine($"Hello, my name is {Name}");
}
}
public class Employee : Person {
public string Position { get; set; }
}Здесь
Employee включает Person как встроенное поле, но не наследует его в традиционном смысле.type Person struct {
Name string
}
func (p Person) Greet() {
fmt.Printf("Hello, my name is %s\n", p.Name)
}
type Employee struct {
Person
Position string
}
func main() {
e := Employee{Person: Person{Name: "John"}, Position: "Developer"}
e.Greet() // Вызов метода Greet из встроенного типа Person
fmt.Println("Position:", e.Position)
}Наследование: Создает жесткую связь между классами, что может привести к хрупким и негибким иерархиям. Подклассы зависят от реализации суперклассов, что может привести к проблемам при изменении суперклассов.
Встраивание: Используется композиция, что способствует более гибкой и модульной архитектуре. Встроенные типы могут быть заменены или изменены без изменения иерархии.
Наследование: Подклассы могут переопределять методы суперклассов, что является основой для полиморфизма.
Встраивание: методы встроенных типов могут быть "переопределены" путем объявления методов с теми же именами в внешнем типе, но это не является полноценным переопределением как в наследовании. Вызов методов не поддерживает виртуальные методы как в C# или Java.
type Person struct {
Name string
}
func (p Person) Greet() {
fmt.Printf("Hello, my name is %s\n", p.Name)
}
type Employee struct {
Person
}
func (e Employee) Greet() {
fmt.Println("Hello, I am an employee")
}
func main() {
e := Employee{Person: Person{Name: "John"}}
e.Greet() // Вызов метода Greet из Employee
e.Person.Greet() // Вызов метода Greet из встроенного типа Person
}Ставь 👍 и забирай 📚 Базу знаний
Please open Telegram to view this post
VIEW IN TELEGRAM
Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний
Please open Telegram to view this post
VIEW IN TELEGRAM