小编Rob*_*Rob的帖子

我正在使用故事板中的一些标准标记，每个标记都有相同的背景色。我遇到的问题是，当segue过渡快要完成时，整个框架周围都会出现像背景这样的深色阴影。

这很微弱，但足以引起问题。有人遇到过吗？

我了解到并发DispatchQueue允许其中的代码立即返回，因此不会阻塞调用线程。这通常与加载大数据的后台任务一起使用。

我还了解到完成处理程序（例如， in URLSession）允许在某些任务完成后执行处理程序中的代码。

我的问题是：这是否意味着并发调度队列和完成处理程序具有重叠的目的？如果我已经使用了完成处理程序，就不需要用并发调度队列包装它吗？

比如下面是一个使用 URLSession 的耗时的数据加载任务，用并发调度队列包装它是不是一个好主意？

URLSession(configuration: URLSessionConfiguration.default).dataTask(with: propertiesRequest) { data, response, error in
        // print("within dataTask: data: \(data), response: \(response), error: \(error)")
        if let error = error {
            print(error)
        } else if let httpResponse = response as? HTTPURLResponse {
            if httpResponse.statusCode == 200 {
                print("success: property task request")


                do {

                    handler(responseDict, nil) // This is a function supplied by caller

                } catch let error as NSError {
                    handler(nil, error)
                }
            }
        }
    }

现在,我正在尝试使用Git中的一个名为Insomnia的类来防止设备在充电时锁定.如果你好奇的话,这个项目就在这里.对于示例代码,它让我这样做:

final class AppDelegate: UIResponder, UIApplicationDelegate {
      private let insomnia = Insomnia(mode: .whenCharging)
      //app delegate code
 }

正如您所看到的,它已声明AppDelegate为final使得insomnia变量未被释放,这将阻止它工作.但是,我不确定,这是不好的做法宣布我AppDelegate的final？或者这会导致我的应用程序出现问题吗？如果这是不好的做法,有没有更好的方法来确保insomnia不被解除分配？

我的 php 代码在服务器上创建了一个空图像

这是我的代码（swift4）：

var encoded_img = imageTobase64(image: image1.image!)

func convertImageToBase64(image: UIImage) -> String {
    let imageData = UIImagePNGRepresentation(image)!
    return imageData.base64EncodedString(options:   Data.Base64EncodingOptions.lineLength64Characters)
}

代码：

$decodimg = base64_decode(_POST["encoded_img"]);
file_put_contents("images/".$imgname,$decodimg);  

以及准备请求的代码：

@IBAction func BtnSend(_ sender: UIButton) {
    var url = "http://xxxxxx/msg.php"
    var encoded_img = imageTobase64(image: image1.image!)    
    let postData = NSMutableData(data: ("message=" + message).data(using: String.Encoding.utf8)!)
    postData.append(("&encoded_img=" + encoded_img).data(using: String.Encoding.utf8)!)    
     request = NSMutableURLRequest(url: NSURL(string: url)! as URL,
 cachePolicy: .useProtocolCachePolicy,
 timeoutInterval: 20.0)
request.httpMethod = "POST"
request.httpBody = postData as Data

let session = URLSession.shared

let …

我正在尝试制作一个为用户绘制对象的应用程序.我现在有一个这样的对象,它是由一个类型的数组构成的[UIBezierPath].然后我使用循环UIBezierPath将数组中的所有s 更改为CGPaths,然后想要逐个绘制那些路径的动画.但是,当我尝试使用此代码时,它不起作用,我无法在网上找到任何有用的信息.这是代码被使用来转换阵列macbookPath它由UIBezierPath成CGPath:

for path in macbookPath {
        drawingPath.append(path.cgPath)
    }

然后我使用此代码尝试绘制路径:

for cgPath in drawingPath {
        shapeLayer.path = cgPath
    }

这是函数的其余代码,drawForm()它应该将表单绘制到一个名为的视图上aiDrawView:

@objc func drawForm() {
    var drawingPath = [CGPath]()
    var macbookPath = Forms.MacbookForm()
    let shapeLayer = CAShapeLayer()
    shapeLayer.frame = aiDrawView.bounds

    for path in macbookPath {
        drawingPath.append(path.cgPath)
    }

    for cgPath in drawingPath {
        shapeLayer.path = cgPath
    }

    let strokeEndAnimation = CABasicAnimation(keyPath: "strokeEnd")
    strokeEndAnimation.duration = 2.0
    strokeEndAnimation.fromValue …

这段代码会死锁，因为：

1. 他们在同一个线程中
2. 打印（2）必须等待打印（3）
3. 打印（3）必须等待打印（2）

例如：

DispatchQueue.main.async {
    print(Thread.current)
    DispatchQueue.main.sync {
        print(Thread.current)
        print(2)
    }
    print(3)
}

为什么在concurrentQueue不会造成死锁？他们也在同一个线程中。

DispatchQueue.global().async {
    print(Thread.current)
    DispatchQueue.global().sync {
        print(Thread.current)
        print(2)
    }
    print(3)
}

假设我们有一个共享资源，许多不同的全局队列都可以访问该资源，并且为了解决这个问题，我们使用调度信号量来管理该访问。当这些全局队列之一告诉信号量等待时，信号量计数就会递减，并且该线程可以访问共享资源。是否有可能在信号量等待时，另一个（不同的）全局队列尝试访问这个共享资源，而GCD从其池中抓取的线程与为前一个队列（当前正在制作的队列）抓取的线程相同信号量等待）这会导致该线程死锁并阻止信号量计数重新递增？

在 xcode 仪器中，我遇到此方法内存泄漏

- (void)getDataForRequest:(NSURLRequest *)request completionHandler:(downloadCompletionBlock)completionHandler
{
    self.expectedLength = 0;
    self.currentLength = 0;
    self.responseData = Nil;
    
    self.contentLengthBlock = nil;
    self.completionBlock = completionHandler;
    
    NSURLSession *session = [NSURLSession sharedSession];
    
    NSURLSessionConfiguration *defaultConfigObject = [NSURLSessionConfiguration defaultSessionConfiguration];
    
    session = [NSURLSession sessionWithConfiguration:defaultConfigObject delegate: self delegateQueue: [NSOperationQueue mainQueue]];
    
    self.postDataTask = [session dataTaskWithRequest:request];
    
    [self.postDataTask resume];
}

通过使用以下代码，我期望每次调用 func 时，执行之间的最短时间为 3-4 秒。

但是：当我writeData()连续调用4 次时，我看到异步块在不等待前一次调用完成的情况下执行。

func writeData(){
    DispatchQueue(label: "be.io").asyncAfter(deadline: .now() + 1) {
        print("START :\(Int64((Date().timeIntervalSince1970 * 1000.0).rounded()))")
        Thread.sleep(forTimeInterval: 3)
    }
}
...
writeData()
writeData()
writeData()
writeData()

预期的输出应该是这样的：

START :1611250630000
START :1611250634000
START :1611250638000
START :1611250642000

但在执行时，我得到了所有 4 个调用相同的时间戳（大约 1 毫秒的差异）。

START :1611250630000
START :1611250630000
START :1611250630000
START :1611250630000

我在做什么错？

PS我毫不拖延地尝试了异步，没有运气。

我写一个演示

let queue = DispatchQueue.global()
queue.async {
    let group = DispatchGroup()
    group.enter()
    DispatchQueue.global().asyncAfter(deadline: DispatchTime.now(), qos: .default) {
        //do sth in default queue
        group.leave()
    }
    group.wait()
    DispatchQueue.main.async { [weak self] in
        //do sth in main queue
    }
}

然后我收到线程性能检查警告

以 QOS_CLASS_USER_INITIATED 运行的线程正在等待以 QOS_CLASS_DEFAULT 运行的较低 QoS 线程。研究避免优先级倒置的方法

我尝试打印它显示的外部队列的 qos

(lldb) print queue.qos
(Dispatch.DispatchQoS) $R0 = {
  qosClass = unspecified   //I think this should be default.
  relativePriority = 0
}

苹果文档错了？

class func global(qos: DispatchQoS.QoSClass = .default) -> DispatchQueue